Bagikan melalui

Substitusi dalam Ekspresi Reguler

Substitusi adalah elemen bahasa yang hanya dikenali dalam pola substitusi. Mereka menggunakan pola ekspresi reguler untuk menentukan semua atau sebagian teks yang akan menggantikan teks yang cocok dalam string input. Pola penggantian dapat terdiri dari satu atau beberapa substitusi bersama dengan karakter harfiah. Pola penggantian disediakan untuk overload metode Regex.Replace yang memiliki parameter replacement dan untuk metode Match.Result. Metode mengganti pola yang cocok dengan pola yang ditentukan oleh replacement parameter .

.NET menentukan elemen substitusi yang tercantum dalam tabel berikut.

Substitusi Deskripsi
$ angka Menyertakan substring terakhir yang cocok dengan grup penangkapan yang diidentifikasi berdasarkan angka, di mana angka adalah nilai desimal, dalam string pengganti. Untuk informasi selengkapnya, lihat Mengganti Grup Bernomor.
${ name } Menyertakan substring terakhir yang cocok dengan grup bernama yang ditunjuk sebagai (?<nama> ) dalam string pengganti. Untuk informasi lebih lanjut, lihat Mengganti Grup Bernama.
$$ Menyertakan satu karakter literal "$" dalam string pengganti. Untuk informasi selengkapnya, lihat Mengganti Simbol "$".
$& Menyertakan salinan seluruh kecocokan dalam string pengganti. Untuk informasi selengkapnya, silakan lihat Mengganti Seluruh Kecocokan.
$` Menyertakan semua teks string input sebelum kecocokan dalam string pengganti. Untuk informasi selengkapnya, lihat Mengganti Teks Sebelum Pencocokan.
$' Menyertakan semua teks masukan setelah kecocokan dalam teks pengganti. Untuk informasi selengkapnya, lihat Mengganti Teks setelah Pencocokan.
$+ Menyertakan grup terakhir yang ditangkap ke dalam string pengganti. Untuk informasi selengkapnya, lihat Menggantikan Grup Terakhir yang diambil.
$_ Menyertakan seluruh string input dalam string pengganti. Untuk informasi selengkapnya, lihat Mengganti Seluruh String Input.

Elemen Substitusi dan Pola Penggantian

Substitusi adalah satu-satunya konstruksi khusus yang dikenali dalam pola penggantian. Tidak ada elemen bahasa ekspresi reguler lainnya yang didukung, termasuk karakter escape dan titik (.), yang cocok dengan karakter apa pun. Demikian pula, elemen bahasa pengganti hanya dikenali dalam pola penggantian dan tidak pernah valid dalam pola ekspresi reguler.

Satu-satunya karakter yang dapat muncul baik dalam pola ekspresi reguler atau dalam penggantian adalah $ karakter, meskipun memiliki arti yang berbeda dalam setiap konteks. Dalam pola ekspresi reguler, $ adalah jangkar yang cocok dengan akhir string. Dalam pola pengganti, $ menunjukkan awal penggantian.

Nota

Untuk fungsionalitas yang mirip dengan pola penggantian dalam ekspresi reguler, gunakan backreference. Untuk informasi selengkapnya tentang backreference, lihat Konstruksi Backreference.

Mengganti Grup Bernomor

Elemen $ bahasa angka mencakup substring terakhir yang cocok dengan grup penangkapan angka dalam string pengganti, di mana angka adalah indeks grup penangkapan. Misalnya, pola pengganti $1 menunjukkan bahwa substring yang cocok akan digantikan oleh grup tangkapan pertama. Untuk informasi lebih lanjut tentang kelompok tangkapan bernomor, silakan merujuk ke Konstruksi Pengelompokan.

Semua digit yang mengikuti $ ditafsirkan sebagai milik grup angka . Jika ini bukan niat Anda, Anda dapat mengganti grup bernama sebagai gantinya. Misalnya, Anda dapat menggunakan string ${1}1 sebagai pengganti $11 untuk menentukan string pengganti sebagai nilai dari grup pertama yang diambil bersama dengan angka "1". Untuk informasi lebih lanjut, lihat Mengganti Grup Bernama.

Menangkap grup yang tidak diberi nama secara eksplisit menggunakan (?< sintaks nama>) dinomor dari kiri ke kanan mulai dari satu. Grup bernama juga diberi nomor dari kiri ke kanan, dimulai dari satu lebih tinggi dari indeks grup terakhir yang tanpa nama. Misalnya, dalam ekspresi reguler (\w)(?<digit>\d), indeks grup bernama digit adalah 2.

Jika angka tidak menentukan grup penangkapan valid yang ditentukan dalam pola ekspresi reguler, $angka ditafsirkan sebagai urutan karakter harfiah yang digunakan untuk mengganti setiap kecocokan.

Contoh berikut menggunakan substitusi $angka untuk menghapus simbol mata uang dari nilai desimal. Ini menghapus simbol mata uang yang ditemukan di awal atau akhir nilai moneter, dan mengenali dua pemisah desimal yang paling umum ("." dan ",").

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

Pola regex \p{Sc}*(\s?\d+[.,]?\d*)\p{Sc}* didefinisikan seperti yang ditunjukkan pada tabel berikut.

Pola Deskripsi
\p{Sc}* Cocokkan nol atau lebih karakter simbol mata uang.
\s? Cocokkan nol atau satu karakter spasi kosong.
\d+ Cocokkan satu atau beberapa angka desimal.
[.,]? Cocokkan nol atau satu titik atau koma.
\d* Cocokkan nol atau lebih angka desimal.
(\s?\d+[.,]?\d*) Cocokkan spasi putih diikuti oleh satu atau beberapa digit desimal, diikuti oleh nol atau satu titik atau koma, diikuti dengan nol atau lebih digit desimal. Ini adalah kelompok penangkapan pertama. Karena pola pengganti adalah $1, pemanggilan metode Regex.Replace menggantikan seluruh substring yang cocok dengan grup yang tertangkap ini.

Mengganti Grup Bernama

Elemen ${ bahasa nama} menggantikan substring terakhir yang cocok dengan grup penangkapan nama, di mana nama adalah nama grup penangkapan yang ditentukan oleh (?< elemen bahasa nama>). Untuk informasi lebih lanjut tentang grup penangkapan bernama, lihat Konstruksi Pengelompokan.

Jika nama tidak menentukan grup penangkapan bernama yang valid yang ditentukan dalam pola ekspresi reguler tetapi terdiri dari digit, ${nama} ditafsirkan sebagai grup bernomor.

Jika nama tidak menentukan grup penangkapan bernama yang valid atau grup penangkapan bernomor valid yang ditentukan dalam pola ekspresi reguler, ${nama} ditafsirkan sebagai urutan karakter harfiah yang digunakan untuk menggantikan setiap kecocokan.

Contoh berikut menggunakan substitusi ${nama} untuk menghapus simbol mata uang dari nilai desimal. Ini menghapus simbol mata uang yang ditemukan di awal atau akhir nilai moneter, dan mengenali dua pemisah desimal yang paling umum ("." dan ",").

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

Pola regex \p{Sc}*(?<amount>\s?\d[.,]?\d*)\p{Sc}* didefinisikan seperti yang ditunjukkan pada tabel berikut.

Pola Deskripsi
\p{Sc}* Cocokkan nol atau lebih karakter simbol mata uang.
\s? Cocokkan nol atau satu karakter spasi kosong.
\d+ Cocokkan satu atau beberapa angka desimal.
[.,]? Cocokkan nol atau satu titik atau koma.
\d* Cocokkan nol atau lebih angka desimal.
(?<amount>\s?\d[.,]?\d*) Cocokkan spasi kosong, diikuti oleh satu atau beberapa digit desimal, diikuti dengan nol atau satu titik atau koma, diikuti oleh nol atau lebih digit desimal. Ini adalah grup penangkap bernama amount. Karena pola pengganti adalah ${amount}, pemanggilan metode Regex.Replace menggantikan seluruh substring yang cocok dengan grup yang tertangkap ini.

Mengganti Tanda "$"

Penggantian $$ menyisipkan karakter "$" harfiah dalam string yang diganti.

Contoh berikut menggunakan NumberFormatInfo objek untuk menentukan simbol mata uang budaya saat ini dan penempatannya dalam string mata uang. Kemudian membangun pola ekspresi reguler dan pola penggantian secara dinamis. Jika contoh dijalankan di komputer yang pengaturan lokalnya saat ini adalah en-US, maka akan menghasilkan pola ekspresi reguler \b(\d+)(\.(\d+))? dan pola penggantian $$ $1$2. Pola pengganti menggantikan teks yang cocok dengan simbol mata uang dan spasi yang diikuti oleh grup tangkapan pertama dan kedua.

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($"{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

Pola regex \b(\d+)(\.(\d+))? didefinisikan seperti yang ditunjukkan pada tabel berikut.

Pola Deskripsi
\b Mulai kecocokan di awal batas kata.
(\d+) Cocokkan satu atau beberapa angka desimal. Ini adalah kelompok penangkapan pertama.
\. Cocokkan titik (pemisah desimal).
(\d+) Cocokkan satu atau beberapa angka desimal. Ini adalah kelompok tangkap ketiga.
(\.(\d+))? Cocokkan nol atau satu kemunculan titik diikuti oleh satu atau beberapa digit desimal. Ini adalah kelompok penangkapan kedua.

Menggantikan Seluruh Kecocokan

Substitusi $& mencakup seluruh kecocokan dalam string pengganti. Seringkali, ini digunakan untuk menambahkan substring ke awal atau akhir string yang cocok. Misalnya, ($&) pola pengganti menambahkan tanda kurung ke awal dan akhir setiap kecocokan. Jika tidak ada kecocokan, penggantian $& tidak berpengaruh.

Contoh berikut menggunakan $& substitusi untuk menambahkan tanda kutip di awal dan akhir judul buku yang disimpan dalam array string.

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"

Pola regex ^(\w+\s?)+$ didefinisikan seperti yang ditunjukkan pada tabel berikut.

Pola Deskripsi
^ Mulailah pencocokan dari awal string masukan.
(\w+\s?)+ Cocokkan pola satu atau beberapa karakter kata diikuti oleh nol atau satu karakter spasi putih satu atau beberapa kali.
$ Cocokkan akhir string input.

Pola "$&" pengganti menambahkan tanda kutip secara harfiah di awal dan di akhir setiap kecocokan.

Mengganti Teks Sebelum Pencocokan

Substitusi $` menggantikan string yang cocok dengan seluruh bagian string input sebelum terjadi kecocokan. Artinya, ia menduplikasi string input sampai pada kecocokan sambil menghilangkan teks yang cocok. Teks apa pun yang mengikuti teks yang cocok tidak berubah dalam string hasil. Jika ada beberapa kecocokan dalam string input, teks pengganti berasal dari string input asli, bukan dari string di mana teks telah digantikan oleh kecocokan sebelumnya. (Contoh memberikan ilustrasi.) Jika tidak ada kecocokan $` , penggantian tidak berpengaruh.

Contoh berikut menggunakan pola \d+ ekspresi reguler untuk mencocokkan urutan satu atau beberapa digit desimal dalam string input. String pengganti $` menggantikan digit ini dengan teks sebelum kecocokan.

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($"   {match.Value} at position {match.Index}");

      Console.WriteLine($"Input string:  {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

Dalam contoh ini, string "aa1bb2cc3dd4ee5" input berisi lima kecocokan. Tabel berikut ini menggambarkan bagaimana substitusi $` menyebabkan mesin ekspresi reguler mengganti setiap kecocokan dalam string input. Teks yang disisipkan ditampilkan dalam huruf tebal di kolom hasil.

Pertandingan Posisi Rangkaian sebelum kecocokan String hasil
1 2 Aa aaaabb2cc3dd4ee5
2 5 aa1bb aaaabbaa1bbcc3dd4ee5
3 8 aa1bb2cc aaaabbaa1bbccaa1bb2ccdd4ee5
4 11 aa1bb2cc3dd aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5
5 14 aa1bb2cc3dd4ee aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Menggantikan Teks Setelah Pencocokan

Substitusi $' menggantikan string yang cocok dengan seluruh string input setelah kecocokan. Artinya, ini menduplikasi string input setelah kecocokan saat menghapus teks yang cocok. Teks apa pun yang mendahului teks yang cocok tidak berubah dalam string hasil. Jika tidak ada kecocokan, penggantian $' tidak berpengaruh.

Contoh berikut menggunakan pola \d+ ekspresi reguler untuk mencocokkan urutan satu atau beberapa digit desimal dalam string input. String pengganti $' menggantikan digit ini dengan teks yang mengikuti kecocokan.

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($"   {match.Value} at position {match.Index}");
      Console.WriteLine($"Input string:  {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

Dalam contoh ini, string "aa1bb2cc3dd4ee5" input berisi lima kecocokan. Tabel berikut ini menggambarkan bagaimana substitusi $' menyebabkan mesin ekspresi reguler mengganti setiap kecocokan dalam string input. Teks yang disisipkan ditampilkan dalam huruf tebal di kolom hasil.

Pertandingan Posisi Teks setelah kecocokan String hasil
1 2 bb2cc3dd4ee5 aabb2cc3dd4ee5bb2cc3dd4ee5
2 5 cc3dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5cc3dd4ee5
3 8 dd4ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5dd4ee5
4 11 ee5 aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee5
5 14 String.Empty aabb2cc3dd4ee5bbcc3dd4ee5ccdd4ee5ddee5ee

Mengganti Grup Tangkap Terakhir

Substitusi $+ menggantikan string yang cocok dengan grup terakhir yang diambil. Jika tidak ada grup yang diambil atau jika nilai grup yang ditangkap terakhir adalah String.Empty, $+ penggantian tidak berpengaruh.

Contoh berikut mengidentifikasi kata duplikat dalam string dan menggunakan substitusi $+ untuk menggantinya dengan satu kali kemunculan kata tersebut. Opsi RegexOptions.IgnoreCase ini digunakan untuk memastikan bahwa kata-kata yang memiliki perbedaan huruf besar/kecil tetapi selain itu identik dianggap duplikat.

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.

Pola regex \b(\w+)\s\1\b didefinisikan seperti yang ditunjukkan pada tabel berikut.

Pola Deskripsi
\b Mulai pencocokan pada batas kata.
(\w+) Mencocokkan satu atau beberapa karakter kata. Ini adalah kelompok penangkapan pertama.
\s Sesuaikan karakter spasi putih.
\1 Cocokkan grup yang pertama ditangkap.
\b Akhiri pertandingan pada batas kata.

Mengganti Seluruh String Input

Substitusi $_ menggantikan string yang cocok menjadi keseluruhan string input. Artinya, ini menghapus teks yang cocok dan menggantinya dengan seluruh string, termasuk teks yang cocok.

Contoh berikut cocok dengan satu atau beberapa digit desimal dalam string input. Ini menggunakan substitusi $_ untuk menggantinya dengan seluruh string input.

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:          {input}");
      Console.WriteLine($"String with substitution: {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

Dalam contoh ini, string "ABC123DEF456" input berisi dua kecocokan. Tabel berikut ini menggambarkan bagaimana substitusi $_ menyebabkan mesin ekspresi reguler mengganti setiap kecocokan dalam string input. Teks yang disisipkan ditampilkan dalam huruf tebal di kolom hasil.

Pertandingan Posisi Pertandingan String hasil
1 3 123 ABCABC123DEF456DEF456
2 5 456 ABC123DEF456 ABCABC123DEF456DEF

Lihat juga