Substitusi dalam Ekspresi Reguler

Artikel
04/08/2023

Substitusi adalah elemen bahasa yang hanya dikenali dalam pola penggantian. 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 kelebihan beban Regex.Replace metode yang memiliki replacement parameter dan metode Match.Result. Metode mengganti pola yang cocok dengan pola yang ditentukan oleh replacement parameter.

.NET mendefinisikan elemen substitusi yang tercantum dalam tabel berikut.

Substitusi	Deskripsi
$ number	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.
${ nama }	Menyertakan substring terakhir yang cocok dengan grup bernama yang ditunjuk berdasarkan `(?<`nama`> )` dalam string pengganti. Untuk informasi selengkapnya, lihat Mengganti Grup Bernomor.
$$	Menyertakan satu literal "$" dalam string pengganti. Untuk informasi selengkapnya, lihat Mengganti Simbol a ”$”.
$&	Menyertakan salinan seluruh kecocokan dalam string pengganti. Untuk informasi selengkapnya, lihat Mengganti Seluruh Kecocokan.
$`	Menyertakan semua teks string input sebelum kecocokan dalam string penggantian. Untuk informasi selengkapnya, lihat Mengganti Teks sebelum Kecocokan.
$'	Menyertakan semua teks string input setelah kecocokan dalam string penggantian. Untuk informasi selengkapnya, lihat Mengganti Teks setelah Kecocokan.
$+	Menyertakan grup terakhir yang diambil dalam string pengganti. Untuk informasi selengkapnya, lihat Mengganti Grup terakhir yang Diambil.
$_	Menyertakan seluruh string input dalam string penggantian. Untuk informasi selengkapnya, lihat Mengganti Seluruh Kecocokan.

Elemen Substitusi dan Pola Penggantian

Substitusi adalah satu-satunya konstruksi khusus yang diakui dalam pola penggantian. Tidak ada elemen bahasa pemrogram ekspresi reguler lainnya, termasuk karakter escape dan titik (.), yang cocok dengan karakter apa pun, yang didukung. Demikian pula, elemen bahasa pemrogram 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 penggantian, $ menunjukkan awal penggantian.

Catatan

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 pemrogram angka menyertakan substring terakhir yang cocok dengan grup penangkapan angka dalam string pengganti, di mana angka adalah indeks grup penangkapan. Misalnya, pola penggantian $1 menunjukkan bahwa substring yang cocok akan digantikan oleh grup pertama yang diambil. Untuk informasi selengkapnya tentang menangkap grup, lihat 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 pengganti bukan $11 menentukan string pengganti sebagai nilai grup pertama yang diambil bersama dengan angka "1". Untuk informasi selengkapnya, lihat Mengganti Grup Bernomor.

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

Jika angka tidak menentukan grup penangkapan valid yang ditentukan dalam pola ekspresi reguler, $angka ditafsirkan sebagai urutan karakter literal yang digunakan untuk menggantikan 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 satu atau beberapa angka desimal.
`(\s?\d+[.,]?\d*)`	Cocokkan ruang 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 grup penangkapan pertama. Karena pola penggantian adalah `$1`, panggilan ke Regex.Replace metode menggantikan seluruh substring yang cocok dengan grup yang diambil ini.

Mengganti Grup Bernama

Elemen ${ bahasa pemrogram nama} menggantikan substring terakhir yang cocok dengan nama yang menangkap grup, di mana nama adalah nama grup penangkapan yang ditentukan oleh (?< elemen bahasa nama>). Untuk informasi selengkapnya tentang menangkap grup, 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 ${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}*(?<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 satu atau beberapa angka desimal.
`(?<amount>\s?\d[.,]?\d*)`	Cocokkan ruang 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 grup penangkap bernama `amount`. Karena pola penggantian adalah `${amount}`, panggilan ke Regex.Replace metode menggantikan seluruh substring yang cocok dengan grup yang diambil ini.

Mengganti Karakter "$"

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 pada komputer yang budayanya saat ini adalah en-US, contoh tersebut menghasilkan pola \b(\d+)(\.(\d+))? ekspresi reguler dan pola $$ $1$2penggantian. Pola penggantian mengganti teks yang cocok dengan simbol mata uang dan spasi diikuti oleh grup pertama dan kedua yang diambil.

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

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 grup penangkapan pertama.
`\.`	Cocokkan periode (pemisah desimal).
`(\d+)`	Cocokkan satu atau beberapa angka desimal. Ini adalah grup pengambilan ketiga.
`(\.(\d+))?`	Cocokkan nol atau satu kemunculan titik diikuti oleh satu atau beberapa digit desimal. Ini adalah grup pengambilan kedua.

Mengganti Seluruh Kecocokan

Substitusi $& mencakup seluruh kecocokan dalam string pengganti. Sering kali, ini digunakan untuk menambahkan substring ke awal atau akhir string yang cocok. Misalnya, ($&) pola penggantian menambahkan tanda kurung ke awal dan akhir setiap kecocokan. Jika tidak ada kecocokan $&, substitusi 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
`^`	Mulai pencocokan di awal string input.
`(\w+\s?)+`	Cocokkan pola satu atau lebih karakter kata yang diikuti dengan nol atau satu karakter ruang putih satu kali atau lebih.
`$`	Cocokkan akhir string input.

Pola "$&" penggantian menambahkan tanda kutip harfiah ke awal dan akhir setiap kecocokan.

Mengganti Teks Sebelum Kecocokan

Substitusi $` menggantikan string yang cocok dengan seluruh string input sebelum kecocokan. Artinya, ia menduplikasi string input hingga kecocokan sambil menghapus teks yang cocok. Teks apa pun yang mengikuti teks yang cocok tidak berubah dalam string hasil. Jika ada beberapa kecocokan dalam string input, teks penggantian berasal dari string input asli, bukan dari string tempat teks digantikan oleh kecocokan sebelumnya. (Contoh memberikan ilustrasi.) Jika tidak ada kecocokan $` , substitusi tidak berpengaruh.

Contoh berikut menggunakan pola ekspresi reguler \d+ untuk mencocokkan urutan satu atau beberapa digit desimal dalam string input. String $` penggantian menggantikan digit ini dengan teks yang mendahului 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("   {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

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

Cocokkan	Position	String sebelum kecocokan	String hasil
1	2	aa	aaaabb2cc3dd4ee5
2	5	aa1bb	aaaabbaa1bbcc3dd4ee5
3	8	aa1bb2cc	aaaabbaa1bbccaa1bb2ccdd4ee5
4	11	aa1bb2cc3dd	aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddee5
5	14	aa1bb2cc3dd4ee	aaaabbaa1bbccaa1bb2ccddaa1bb2cc3ddeeaa1bb2cc3dd4ee

Mengganti Teks Setelah Kecocokan

Substitusi $' menggantikan string yang cocok dengan seluruh string input sebelum kecocokan. Artinya, ia menduplikasi string input hingga kecocokan sambil menghapus teks yang cocok. Teks apa pun yang mendahului teks yang cocok tidak berubah dalam string hasil. Jika tidak ada kecocokan $', substitusi tidak berpengaruh.

Contoh berikut menggunakan pola ekspresi reguler \d+ untuk mencocokkan urutan satu atau beberapa digit desimal dalam string input. String $' penggantian menggantikan digit ini dengan teks yang mendahului 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("   {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

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

Cocokkan	Position	String 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 yang Terakhir Diambil

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

Contoh berikut mengidentifikasi kata duplikat dalam string dan menggunakan $+ penggantian untuk menggantinya dengan satu kemunculan kata. Opsi RegexOptions.IgnoreCase ini digunakan untuk memastikan bahwa kata-kata yang berbeda dalam kasus tetapi jika tidak 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`	Memulai pencocokan dalam batas kata.
`(\w+)`	Mencocokkan satu atau beberapa karakter kata. Ini adalah grup penangkapan pertama.
`\s`	Cocokkan karakter spasi kosong.
`\1`	Cocok dengan grup pertama yang diambil.
`\b`	Mengakhiri pencocokan dalam batas kata.

Mengganti seluruh string input

Substitusi $_ menggantikan string yang cocok dengan seluruh string input sebelum kecocokan. 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 $_ penggantian 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:          {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

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

Cocokkan	Position	Cocokkan	String hasil
1	3	123	ABCABC123DEF456DEF456
2	5	456	ABCABC123DEF456DEFABC123DEF456

Lihat juga

Bahasa Regex - Referensi Cepat

Bagikan melalui