Regex.Replace Metode

Referensi

Definisi

Ruang nama:: System.Text.RegularExpressions

Rakitan:: System.Text.RegularExpressions.dll

Rakitan:: System.dll

Rakitan:: netstandard.dll

Penting

Beberapa informasi terkait produk prarilis yang dapat diubah secara signifikan sebelum dirilis. Microsoft tidak memberikan jaminan, tersirat maupun tersurat, sehubungan dengan informasi yang diberikan di sini.

Dalam string input tertentu, mengganti string yang cocok dengan pola ekspresi reguler dengan string pengganti yang ditentukan.

Overload

Replace(String, MatchEvaluator, Int32, Int32)	Dalam substring input tertentu, mengganti jumlah maksimum string tertentu yang cocok dengan pola ekspresi reguler dengan string yang dikembalikan oleh delegasi MatchEvaluator.
Replace(String, String, String)	Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string pengganti yang ditentukan.
Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)	Dalam string input tertentu, mengganti semua substring yang cocok dengan ekspresi reguler tertentu dengan string yang dikembalikan oleh delegasi MatchEvaluator. Parameter tambahan menentukan opsi yang memodifikasi operasi pencocokan dan interval waktu habis jika tidak ada kecocokan yang ditemukan.
Replace(String, String, MatchEvaluator, RegexOptions)	Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string yang dikembalikan oleh delegasi MatchEvaluator. Opsi yang ditentukan mengubah operasi pencocokan.
Replace(String, String, String, RegexOptions, TimeSpan)	Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string pengganti yang ditentukan. Parameter tambahan menentukan opsi yang memodifikasi operasi pencocokan dan interval waktu habis jika tidak ada kecocokan yang ditemukan.
Replace(String, String, String, RegexOptions)	Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string pengganti yang ditentukan. Opsi yang ditentukan mengubah operasi pencocokan.
Replace(String, MatchEvaluator)	Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string yang dikembalikan oleh delegasi MatchEvaluator.
Replace(String, MatchEvaluator, Int32)	Dalam string input tertentu, mengganti jumlah maksimum string tertentu yang cocok dengan pola ekspresi reguler dengan string yang dikembalikan oleh delegasi MatchEvaluator.
Replace(String, String, MatchEvaluator)	Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string yang dikembalikan oleh delegasi MatchEvaluator.
Replace(String, String, Int32)	Dalam string input tertentu, mengganti jumlah maksimum string tertentu yang cocok dengan pola ekspresi reguler dengan string pengganti yang ditentukan.
Replace(String, String)	Dalam string input tertentu, mengganti semua string yang cocok dengan pola ekspresi reguler dengan string pengganti yang ditentukan.
Replace(String, String, Int32, Int32)	Dalam substring input tertentu, menggantikan jumlah maksimum string tertentu yang cocok dengan pola ekspresi reguler dengan string pengganti yang ditentukan.

Replace(String, MatchEvaluator, Int32, Int32)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam substring input tertentu, mengganti jumlah maksimum string tertentu yang cocok dengan pola ekspresi reguler dengan string yang dikembalikan oleh delegasi MatchEvaluator.

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count, int startat);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count, int startat);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int * int -> string

Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer, startat As Integer) As String

Parameter

input: String

String untuk mencari kecocokan.

evaluator: MatchEvaluator

Metode kustom yang memeriksa setiap kecocokan dan mengembalikan string asli yang cocok atau string pengganti.

count: Int32

Jumlah maksimum kali penggantian akan terjadi.

startat: Int32

Posisi karakter dalam string input tempat pencarian dimulai.

Mengembalikan

String

String baru yang identik dengan string input, kecuali bahwa string pengganti menggantikan setiap string yang cocok. Jika pola ekspresi reguler tidak cocok dalam instans saat ini, metode mengembalikan instans saat ini tidak berubah.

Pengecualian

ArgumentNullException

input atau evaluatornull.

ArgumentOutOfRangeException

startat kurang dari nol atau lebih besar dari panjang input.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Keterangan

Metode Regex.Replace(String, MatchEvaluator, Int32, Int32) berguna untuk mengganti kecocokan ekspresi reguler jika salah satu kondisi berikut ini benar:

String pengganti tidak dapat dengan mudah ditentukan oleh pola penggantian ekspresi reguler.
String penggantian dihasilkan dari beberapa pemrosesan yang dilakukan pada string yang cocok.
String penggantian dihasilkan dari pemrosesan bersyarkat.

Metode ini setara dengan memanggil metode Regex.Matches(String, Int32) dan meneruskan objek countMatch pertama dalam koleksi MatchCollection yang dikembalikan ke delegasi evaluator.

Untuk detail selengkapnya tentang startat, lihat bagian Keterangan dari Match(String, Int32).

Ekspresi reguler adalah pola yang ditentukan oleh konstruktor untuk objek Regex saat ini.

Parameter evaluator adalah delegasi untuk metode kustom yang Anda tentukan dan yang memeriksa setiap kecocokan. Metode kustom harus memiliki tanda tangan berikut agar sesuai dengan delegasi MatchEvaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Metode kustom Anda mengembalikan string yang menggantikan input yang cocok.

Pengecualian RegexMatchTimeoutException dilemparkan jika waktu eksekusi operasi penggantian melebihi interval waktu habis yang ditentukan oleh konstruktor Regex.Regex(String, RegexOptions, TimeSpan). Jika Anda tidak mengatur interval waktu habis saat Memanggil konstruktor, pengecualian akan dibuang jika operasi melebihi nilai batas waktu yang ditetapkan untuk domain aplikasi tempat objek Regex dibuat. Jika tidak ada waktu habis yang ditentukan dalam panggilan konstruktor Regex atau di properti domain aplikasi, atau jika nilai batas waktu Regex.InfiniteMatchTimeout, tidak ada pengecualian yang dilemparkan

Karena metode mengembalikan input tidak berubah jika tidak ada kecocokan, Anda dapat menggunakan metode Object.ReferenceEquals untuk menentukan apakah metode telah membuat penggantian pada string input.

Lihat juga

MatchEvaluator
Substitusi dalam Ekspresi Reguler
Bahasa Ekspresi Reguler - Referensi Cepat

Berlaku untuk

Replace(String, String, String)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string pengganti yang ditentukan.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement);

public static string Replace (string input, string pattern, string replacement);

static member Replace : string * string * string -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String) As String

Parameter

input: String

String untuk mencari kecocokan.

pattern: String

Pola ekspresi reguler yang cocok.

replacement: String

String pengganti.

Mengembalikan

String

String baru yang identik dengan string input, kecuali bahwa string pengganti menggantikan setiap string yang cocok. Jika pattern tidak cocok dalam instans saat ini, metode mengembalikan instans saat ini tidak berubah.

Pengecualian

ArgumentException

Terjadi kesalahan penguraian ekspresi reguler.

ArgumentNullException

input, pattern, atau replacementnull.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Contoh

Contoh berikut mendefinisikan ekspresi reguler, \s+, yang cocok dengan satu atau beberapa karakter spasi putih. String pengganti, " ", menggantinya dengan karakter spasi tunggal.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      string result = Regex.Replace(input, pattern, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim result As String = Regex.Replace(input, pattern, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

Contoh berikut menggunakan metode Replace(String, String, String) untuk mengganti nama komputer lokal dan drive di jalur UNC dengan jalur file lokal. Ekspresi reguler menggunakan properti Environment.MachineName untuk menyertakan nama komputer lokal, dan metode Environment.GetLogicalDrives untuk menyertakan nama drive logis. Agar berhasil menjalankan contoh, Anda harus mengganti string harfiah "MyMachine" dengan nama komputer lokal Anda.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\(?i:" + Environment.MachineName + @")(?:\.\w+)*\\((?i:[" + driveNames + @"]))\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

Pola ekspresi reguler ditentukan oleh ekspresi berikut:

"\\\\(?i:" + Environment.MachineName + ")(?:\.\w+)*\\((?i:[" + driveNames + "]))\$"

Tabel berikut ini memperlihatkan bagaimana pola ekspresi reguler ditafsirkan.

Pola	Deskripsi
`\\\\`	Cocokkan dua karakter garis miring terbelakang berturut-turut (`\`). Karena karakter garis miring terbalik ditafsirkan sebagai karakter escape, setiap garis miring terbalik harus diloloskan dengan garis miring terbalik lainnya.
`(?i:" + Environment.MachineName + ")`	Lakukan kecocokan tidak sensitif huruf besar/kecil dari string yang dikembalikan oleh properti Environment.MachineName.
`(?:\.\w+)*`	Cocokkan karakter titik (`.`) diikuti oleh satu atau beberapa karakter kata. Kecocokan ini dapat terjadi nol atau lebih kali. Subekspresi yang cocok tidak diambil.
`\\`	Cocokkan karakter garis miring terbelakang (`\`).
`((?i:[" + driveNames + "]))`	Lakukan kecocokan yang tidak peka huruf besar/kecil dari kelas karakter yang terdiri dari huruf drive individual. Kecocokan ini adalah subekspresi pertama yang ditangkap.
`\$`	Cocokkan karakter tanda dolar harfiah (`$`).

Pola penggantian $1 menggantikan seluruh kecocokan dengan subekspresi pertama yang diambil. Artinya, ia menggantikan komputer UNC dan nama drive dengan huruf kandar.

Keterangan

Metode Replace statis setara dengan membangun objek Regex dengan pola ekspresi reguler yang ditentukan dan memanggil metode instans Replace.

Parameter replacement menentukan string yang akan menggantikan setiap kecocokan di input. replacement dapat terdiri dari kombinasi teks harfiah dan substitusi . Misalnya, pola penggantian a*${test}b menyisipkan string "a*" diikuti dengan substring yang cocok dengan grup penangkapan test, jika ada, diikuti oleh string "b". Karakter * tidak dikenali sebagai metacharacter dalam pola penggantian.

Nota

Penggantian adalah satu-satunya elemen bahasa ekspresi reguler yang dikenali dalam pola pengganti. Semua elemen bahasa ekspresi reguler lainnya, termasuk karakter lolos, hanya diizinkan dalam pola ekspresi reguler dan tidak dikenali dalam pola penggantian.

Pengecualian RegexMatchTimeoutException dilemparkan jika waktu eksekusi operasi penggantian melebihi interval waktu habis yang ditentukan untuk domain aplikasi tempat metode dipanggil. Jika tidak ada waktu habis yang ditentukan dalam properti domain aplikasi, atau jika nilai batas waktu Regex.InfiniteMatchTimeout, tidak ada pengecualian yang dilemparkan.

Catatan Bagi Pemanggil

Metode ini kehabisan waktu setelah interval yang sama dengan nilai batas waktu default domain aplikasi di mana ia dipanggil. Jika nilai waktu habis belum ditentukan untuk domain aplikasi, nilai InfiniteMatchTimeout, yang mencegah metode kehabisan waktu, digunakan. Metode statis yang direkomendasikan untuk mengganti kecocokan pola adalah Replace(String, String, String, RegexOptions, TimeSpan), yang memungkinkan Anda mengatur interval waktu habis.

Lihat juga

Substitusi dalam Ekspresi Reguler
Elemen Bahasa Ekspresi Reguler

Berlaku untuk

Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam string input tertentu, mengganti semua substring yang cocok dengan ekspresi reguler tertentu dengan string yang dikembalikan oleh delegasi MatchEvaluator. Parameter tambahan menentukan opsi yang memodifikasi operasi pencocokan dan interval waktu habis jika tidak ada kecocokan yang ditemukan.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions, matchTimeout As TimeSpan) As String

Parameter

input: String

String untuk mencari kecocokan.

pattern: String

Pola ekspresi reguler yang cocok.

evaluator: MatchEvaluator

Metode kustom yang memeriksa setiap kecocokan dan mengembalikan string asli yang cocok atau string pengganti.

options: RegexOptions

Kombinasi bitwise dari nilai enumerasi yang menyediakan opsi untuk pencocokan.

matchTimeout: TimeSpan

Interval waktu habis, atau InfiniteMatchTimeout untuk menunjukkan bahwa metode tidak boleh kehabisan waktu.

Mengembalikan

String

Pengecualian

ArgumentException

Terjadi kesalahan penguraian ekspresi reguler.

ArgumentNullException

input, pattern, atau evaluatornull.

ArgumentOutOfRangeException

options bukan kombinasi bitwise yang valid dari nilai RegexOptions.

-atau-

matchTimeout negatif, nol, atau lebih besar dari sekitar 24 hari.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Contoh

Contoh berikut menggunakan ekspresi reguler untuk mengekstrak kata individual dari string, lalu menggunakan delegasi MatchEvaluator untuk memanggil metode bernama WordScramble yang mengacak huruf individual dalam kata. Untuk melakukan ini, metode WordScramble membuat array yang berisi karakter dalam kecocokan. Ini juga membuat array paralel yang diisi dengan angka floating-point acak. Array diurutkan dengan memanggil metode Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>), dan array yang diurutkan disediakan sebagai argumen ke konstruktor kelas String. String yang baru dibuat ini kemudian dikembalikan oleh metode WordScramble. Pola ekspresi reguler \w+ cocok dengan satu atau beberapa karakter kata; mesin ekspresi reguler akan terus menambahkan karakter ke kecocokan hingga menemukan karakter non-kata, seperti karakter spasi putih. Panggilan ke metode Replace(String, String, MatchEvaluator, RegexOptions) menyertakan opsi RegexOptions.IgnorePatternWhitespace sehingga komentar dalam pola ekspresi reguler \w+ # Matches all the characters in a word. diabaikan oleh mesin ekspresi reguler.

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      try {
         Console.WriteLine("Scrambled words:");
         Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)));      
      }
      catch (RegexMatchTimeoutException) {
         Console.WriteLine("Word Scramble operation timed out.");
         Console.WriteLine("Returned words:");
      }
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Try
         Console.WriteLine("Scrambled words:")
         Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                         RegexOptions.IgnorePatternWhitespace,
                                         TimeSpan.FromSeconds(.25)))      
      Catch e As RegexMatchTimeoutException
         Console.WriteLine("Word Scramble operation timed out.")
         Console.WriteLine("Returned words:")
      End Try   
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Keterangan

Metode Regex.Replace(String, String, MatchEvaluator, RegexOptions) berguna untuk mengganti kecocokan ekspresi reguler jika salah satu kondisi berikut ini benar:

Jika string pengganti tidak dapat dengan mudah ditentukan oleh pola penggantian ekspresi reguler.
Jika string pengganti dihasilkan dari beberapa pemrosesan yang dilakukan pada string yang cocok.
Jika string pengganti dihasilkan dari pemrosesan bersyarah.

Metode ini setara dengan memanggil metode Regex.Matches(String, String, RegexOptions) dan meneruskan setiap objek Match dalam koleksi MatchCollection yang dikembalikan ke delegasi evaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Metode kustom Anda mengembalikan string yang menggantikan input yang cocok.

Jika Anda menentukan RightToLeft untuk parameter options, pencarian kecocokan dimulai di akhir string input dan bergerak ke kiri; jika tidak, pencarian dimulai pada awal string input dan bergerak ke kanan.

Parameter matchTimeout menentukan berapa lama metode pencocokan pola harus mencoba menemukan kecocokan sebelum waktu habis. Mengatur interval waktu habis mencegah ekspresi reguler yang mengandalkan backtracking yang berlebihan muncul ke "berhenti merespons saat mereka memproses input yang berisi kecocokan dekat. Untuk informasi selengkapnya, lihat Praktik Terbaik untuk Ekspresi Reguler dan Backtracking. Jika tidak ada kecocokan yang ditemukan dalam interval waktu tersebut, metode akan memberikan pengecualian RegexMatchTimeoutException. matchTimeout mengambil alih nilai batas waktu default yang ditentukan untuk domain aplikasi tempat metode dijalankan.

Catatan Bagi Pemanggil

Kami menyarankan agar Anda mengatur parameter matchTimeout ke nilai yang sesuai, seperti dua detik. Jika Anda menonaktifkan waktu habis dengan menentukan InfiniteMatchTimeout, mesin ekspresi reguler menawarkan performa yang sedikit lebih baik. Namun, Anda harus menonaktifkan batas waktu hanya dalam kondisi berikut:

Ketika input yang diproses oleh ekspresi reguler berasal dari sumber yang diketahui dan tepercaya atau terdiri dari teks statis. Ini mengecualikan teks yang telah dimasukkan secara dinamis oleh pengguna.
Ketika pola ekspresi reguler telah diuji secara menyeluruh untuk memastikan bahwa pola regex secara efisien menangani kecocokan, non-kecocokan, dan mendekati kecocokan.
Ketika pola ekspresi reguler tidak berisi elemen bahasa yang diketahui menyebabkan backtracking yang berlebihan saat memproses kecocokan dekat.

Lihat juga

RegexOptions
Substitusi dalam Ekspresi Reguler
Elemen Bahasa Ekspresi Reguler
Backtracking dalam ekspresi reguler
Praktik terbaik untuk ekspresi reguler di .NET

Berlaku untuk

Replace(String, String, MatchEvaluator, RegexOptions)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string yang dikembalikan oleh delegasi MatchEvaluator. Opsi yang ditentukan mengubah operasi pencocokan.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, System::Text::RegularExpressions::RegexOptions options);

public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator, System.Text.RegularExpressions.RegexOptions options);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator, options As RegexOptions) As String

Parameter

input: String

String untuk mencari kecocokan.

pattern: String

Pola ekspresi reguler yang cocok.

evaluator: MatchEvaluator

Metode kustom yang memeriksa setiap kecocokan dan mengembalikan string asli yang cocok atau string pengganti.

options: RegexOptions

Kombinasi bitwise dari nilai enumerasi yang menyediakan opsi untuk pencocokan.

Mengembalikan

String

Pengecualian

ArgumentException

Terjadi kesalahan penguraian ekspresi reguler.

ArgumentNullException

input, pattern, atau evaluatornull.

ArgumentOutOfRangeException

options bukan kombinasi bitwise yang valid dari nilai RegexOptions.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Contoh

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+  # Matches all the characters in a word.";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator, 
                                      RegexOptions.IgnorePatternWhitespace));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+  # Matches all the characters in a word."                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator,
                                      RegexOptions.IgnorePatternWhitespace))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    etlert liahepalbcat imsgsni alkc ereelsa epcnnaht lscak cayirllc alnyurd ecsae

Keterangan

Metode Regex.Replace(String, String, MatchEvaluator, RegexOptions) berguna untuk mengganti kecocokan ekspresi reguler jika salah satu kondisi berikut ini benar:

String pengganti tidak dapat dengan mudah ditentukan oleh pola penggantian ekspresi reguler.
String penggantian dihasilkan dari beberapa pemrosesan yang dilakukan pada string yang cocok.
String penggantian dihasilkan dari pemrosesan bersyarkat.

Metode ini setara dengan memanggil metode Regex.Matches(String, String, RegexOptions) dan meneruskan setiap objek Match dalam koleksi MatchCollection yang dikembalikan ke delegasi evaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Metode kustom Anda mengembalikan string yang menggantikan input yang cocok.

Lihat juga

Berlaku untuk

Replace(String, String, String, RegexOptions, TimeSpan)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string pengganti yang ditentukan. Parameter tambahan menentukan opsi yang memodifikasi operasi pencocokan dan interval waktu habis jika tidak ada kecocokan yang ditemukan.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options, TimeSpan matchTimeout);

public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options, TimeSpan matchTimeout);

static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions * TimeSpan -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions, matchTimeout As TimeSpan) As String

Parameter

input: String

String untuk mencari kecocokan.

pattern: String

Pola ekspresi reguler yang cocok.

replacement: String

String pengganti.

options: RegexOptions

Kombinasi bitwise dari nilai enumerasi yang menyediakan opsi untuk pencocokan.

matchTimeout: TimeSpan

Interval waktu habis, atau InfiniteMatchTimeout untuk menunjukkan bahwa metode tidak boleh kehabisan waktu.

Mengembalikan

String

Pengecualian

ArgumentException

Terjadi kesalahan penguraian ekspresi reguler.

ArgumentNullException

input, pattern, atau replacementnull.

ArgumentOutOfRangeException

options bukan kombinasi bitwise yang valid dari nilai RegexOptions.

-atau-

matchTimeout negatif, nol, atau lebih besar dari sekitar 24 hari.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Contoh

Contoh berikut menggunakan metode Replace(String, String, String, RegexOptions, TimeSpan) untuk mengganti nama komputer lokal dan drive di jalur UNC dengan jalur file lokal. Ekspresi reguler menggunakan properti Environment.MachineName untuk menyertakan nama komputer lokal dan metode Environment.GetLogicalDrives untuk menyertakan nama drive logis. Semua perbandingan string ekspresi reguler tidak peka huruf besar/kecil, dan waktu operasi penggantian tunggal habis jika kecocokan tidak dapat ditemukan dalam 0,5 detik. Agar berhasil menjalankan contoh, Anda harus mengganti string harfiah "MyMachine" dengan nama komputer lokal Anda.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         string localPath = null;
         try {
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                      RegexOptions.IgnoreCase,
                                      TimeSpan.FromSeconds(0.5));
            Console.WriteLine("Returned string: " + localPath);
         }
         catch (RegexMatchTimeoutException) {
            Console.WriteLine("The replace operation timed out.");
            Console.WriteLine("Returned string: " + localPath);
            if (uncPath.Equals(localPath)) 
               Console.WriteLine("Equal to original path.");
            else
               Console.WriteLine("Original string: " + uncPath);
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Dim localPath As String = Nothing
         Try
            localPath = Regex.Replace(uncPath, pattern, replacement, 
                                                               RegexOptions.IgnoreCase,
                                                               TimeSpan.FromSeconds(0.5))
            Console.WriteLine("Returned string: " + localPath)         
         Catch e As RegexMatchTimeoutException
            Console.WriteLine("The replace operation timed out.")
            Console.WriteLine("Returned string: " + localPath)
            If uncPath.Equals(localPath) Then 
               Console.WriteLine("Equal to original path.")
            Else
               Console.WriteLine("Original string: " + uncPath)
            End If
         End Try         
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

Pola ekspresi reguler ditentukan oleh ekspresi berikut:

"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

Tabel berikut ini memperlihatkan bagaimana pola ekspresi reguler ditafsirkan.

Pola	Deskripsi
`\\\\`	Cocokkan dua karakter garis miring terbelakang berturut-turut (`\`). Karena karakter garis miring terbalik ditafsirkan sebagai karakter escape, setiap garis miring terbalik harus diloloskan dengan garis miring terbalik lainnya.
`+ Environment.MachineName +`	Cocokkan string yang dikembalikan oleh properti Environment.MachineName.
`(?:\.\w+)*`	Cocokkan karakter titik (`.`) diikuti oleh satu atau beberapa karakter kata. Kecocokan ini dapat terjadi nol atau lebih kali. Subekspresi yang cocok tidak diambil.
`\\`	Cocokkan karakter garis miring terbelakang (`\`).
`([" + driveNames + "])`	Cocokkan kelas karakter yang terdiri dari huruf drive individual. Kecocokan ini adalah subekspresi pertama yang ditangkap.
`\$`	Cocokkan karakter tanda dolar harfiah (`$`).

Pola penggantian $1 menggantikan seluruh kecocokan dengan subekspresi pertama yang diambil. Artinya, ia menggantikan komputer UNC dan nama drive dengan huruf kandar.

Keterangan

Metode Replace statis setara dengan membangun objek Regex dengan pola ekspresi reguler yang ditentukan dan memanggil metode instans Replace.

Parameter pattern terdiri dari elemen bahasa ekspresi reguler yang secara simbolis menggambarkan string yang cocok. Untuk informasi selengkapnya tentang ekspresi reguler, lihat Ekspresi Reguler .NET dan Bahasa Ekspresi Reguler - Referensi Cepat. Jika Anda menentukan RightToLeft untuk parameter options, pencarian kecocokan dimulai di akhir string input dan bergerak ke kiri; jika tidak, pencarian dimulai pada awal string input dan bergerak ke kanan.

Nota

Parameter matchTimeout menentukan berapa lama metode pencocokan pola harus mencoba menemukan kecocokan sebelum waktu habis. Mengatur interval waktu habis mencegah ekspresi reguler yang mengandalkan backtracking yang berlebihan muncul untuk berhenti merespons saat mereka memproses input yang berisi kecocokan dekat. Untuk informasi selengkapnya, lihat Praktik Terbaik untuk Ekspresi Reguler dan Backtracking. Jika tidak ada kecocokan yang ditemukan dalam interval waktu tersebut, metode akan memberikan pengecualian RegexMatchTimeoutException. matchTimeout mengambil alih nilai batas waktu default yang ditentukan untuk domain aplikasi tempat metode dijalankan.

Catatan Bagi Pemanggil

Ketika input yang diproses oleh ekspresi reguler berasal dari sumber yang diketahui dan tepercaya atau terdiri dari teks statis. Ini mengecualikan teks yang telah dimasukkan secara dinamis oleh pengguna.
Ketika pola ekspresi reguler telah diuji secara menyeluruh untuk memastikan bahwa pola regex secara efisien menangani kecocokan, non-kecocokan, dan mendekati kecocokan.
Ketika pola ekspresi reguler tidak berisi elemen bahasa yang diketahui menyebabkan backtracking yang berlebihan saat memproses kecocokan dekat.

Lihat juga

RegexOptions
Substitusi dalam Ekspresi Reguler
Elemen Bahasa Ekspresi Reguler
Backtracking dalam ekspresi reguler
Praktik terbaik untuk ekspresi reguler di .NET

Berlaku untuk

Replace(String, String, String, RegexOptions)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string pengganti yang ditentukan. Opsi yang ditentukan mengubah operasi pencocokan.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::String ^ replacement, System::Text::RegularExpressions::RegexOptions options);

public static string Replace (string input, string pattern, string replacement, System.Text.RegularExpressions.RegexOptions options);

static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions -> string

Public Shared Function Replace (input As String, pattern As String, replacement As String, options As RegexOptions) As String

Parameter

input: String

String untuk mencari kecocokan.

pattern: String

Pola ekspresi reguler yang cocok.

replacement: String

String pengganti.

options: RegexOptions

Kombinasi bitwise dari nilai enumerasi yang menyediakan opsi untuk pencocokan.

Mengembalikan

String

Pengecualian

ArgumentException

Terjadi kesalahan penguraian ekspresi reguler.

ArgumentNullException

input, pattern, atau replacementnull.

ArgumentOutOfRangeException

options bukan kombinasi bitwise yang valid dari nilai RegexOptions.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Contoh

Contoh berikut menggunakan metode Replace(String, String, String, RegexOptions) untuk mengganti nama komputer lokal dan drive di jalur UNC dengan jalur file lokal. Ekspresi reguler menggunakan properti Environment.MachineName untuk menyertakan nama komputer lokal, dan metode Environment.GetLogicalDrives untuk menyertakan nama drive logis. Semua perbandingan string ekspresi reguler tidak peka huruf besar/kecil. Agar berhasil menjalankan contoh, Anda harus mengganti string harfiah "MyMachine" dengan nama komputer lokal Anda.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      // Get drives available on local computer and form into a single character expression.
      string[] drives = Environment.GetLogicalDrives();
      string driveNames = String.Empty;
      foreach (string drive in drives)
         driveNames += drive.Substring(0,1);
      // Create regular expression pattern dynamically based on local machine information.
      string pattern = @"\\\\" + Environment.MachineName + @"(?:\.\w+)*\\([" + driveNames + @"])\$";

      string replacement = "$1:";
      string[] uncPaths = { @"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", 
                            @"\\MyMachine\c$\ThingsToDo.txt", 
                            @"\\MyMachine\d$\documents\mydocument.docx" }; 
      
      foreach (string uncPath in uncPaths)
      {
         Console.WriteLine("Input string: " + uncPath);
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase));
         Console.WriteLine();
      }
   }
}
// The example displays the following output if run on a machine whose name is
// MyMachine:
//    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
//    Returned string: C:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\c$\ThingsToDo.txt
//    Returned string: c:\ThingsToDo.txt
//    
//    Input string: \\MyMachine\d$\documents\mydocument.docx
//    Returned string: d:\documents\mydocument.docx

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      ' Get drives available on local computer and form into a single character expression.
      Dim drives() As String = Environment.GetLogicalDrives()
      Dim driveNames As String = Nothing
      For Each drive As String In drives
         driveNames += drive.Substring(0,1)
      Next
      ' Create regular expression pattern dynamically based on local machine information.
      Dim pattern As String = "\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

      Dim replacement As String = "$1:"
      Dim uncPaths() AS String = {"\\MyMachine.domain1.mycompany.com\C$\ThingsToDo.txt", _
                                  "\\MyMachine\c$\ThingsToDo.txt", _
                                  "\\MyMachine\d$\documents\mydocument.docx" } 
      
      For Each uncPath As String In uncPaths
         Console.WriteLine("Input string: " + uncPath)
         Console.WriteLine("Returned string: " + Regex.Replace(uncPath, pattern, replacement, RegexOptions.IgnoreCase))
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output if run on a machine whose name is
' MyMachine:
'    Input string: \\MyMachine.domain1.mycompany.com\C$\ThingsToTo.txt
'    Returned string: C:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\c$\ThingsToDo.txt
'    Returned string: c:\ThingsToDo.txt
'    
'    Input string: \\MyMachine\d$\documents\mydocument.docx
'    Returned string: d:\documents\mydocument.docx

Pola ekspresi reguler ditentukan oleh ekspresi berikut:

"\\\\" + Environment.MachineName + "(?:\.\w+)*\\([" + driveNames + "])\$"

Tabel berikut ini memperlihatkan bagaimana pola ekspresi reguler ditafsirkan.

Pola	Deskripsi
`\\\\`	Cocokkan dua karakter garis miring terbelakang berturut-turut (`\`). Karena karakter garis miring terbalik ditafsirkan sebagai karakter escape, setiap garis miring terbalik harus diloloskan dengan garis miring terbalik lainnya.
`+ Environment.MachineName +`	Cocokkan string yang dikembalikan oleh properti Environment.MachineName.
`(?:\.\w+)*`	Cocokkan karakter titik (`.`) diikuti oleh satu atau beberapa karakter kata. Kecocokan ini dapat terjadi nol atau lebih kali. Subekspresi yang cocok tidak diambil.
`\\`	Cocokkan karakter garis miring terbelakang (`\`).
`([" + driveNames + "])`	Cocokkan kelas karakter yang terdiri dari huruf drive individual. Kecocokan ini adalah subekspresi pertama yang ditangkap.
`\$`	Cocokkan karakter tanda dolar harfiah (`$`).

Pola penggantian $1 menggantikan seluruh kecocokan dengan subekspresi pertama yang diambil. Artinya, ia menggantikan komputer UNC dan nama drive dengan huruf kandar.

Keterangan

Metode Replace statis setara dengan membangun objek Regex dengan pola ekspresi reguler yang ditentukan dan memanggil metode instans Replace.

Nota

Catatan Bagi Pemanggil

Lihat juga

RegexOptions
Substitusi dalam Ekspresi Reguler
Elemen Bahasa Ekspresi Reguler

Berlaku untuk

Replace(String, MatchEvaluator)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string yang dikembalikan oleh delegasi MatchEvaluator.

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator -> string

Public Function Replace (input As String, evaluator As MatchEvaluator) As String

Parameter

input: String

String untuk mencari kecocokan.

evaluator: MatchEvaluator

Metode kustom yang memeriksa setiap kecocokan dan mengembalikan string asli yang cocok atau string pengganti.

Mengembalikan

String

Pengecualian

ArgumentNullException

input atau evaluatornull.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Contoh

Contoh kode berikut menampilkan string asli, cocok dengan setiap kata dalam string asli, mengonversi karakter pertama dari setiap kecocokan menjadi huruf besar, lalu menampilkan string yang dikonversi.

using System;
using System.Text.RegularExpressions;

class RegExSample
{
    static string CapText(Match m)
    {
        // Get the matched string.
        string x = m.ToString();
        // If the first char is lower case...
        if (char.IsLower(x[0]))
        {
            // Capitalize it.
            return char.ToUpper(x[0]) + x.Substring(1, x.Length - 1);
        }
        return x;
    }

    static void Main()
    {
        string text = "four score and seven years ago";

        Console.WriteLine($"text=[{text}]");

        Regex rx = new Regex(@"\w+");

        string result = rx.Replace(text, new MatchEvaluator(RegExSample.CapText));

        Console.WriteLine($"result=[{result}]");
    }
}
// The example displays the following output:
//       text=[four score and seven years ago]
//       result=[Four Score And Seven Years Ago]

Imports System.Text.RegularExpressions

Module RegExSample
    Function CapText(ByVal m As Match) As String
        ' Get the matched string.
        Dim x As String = m.ToString()
        ' If the first char is lower case...
        If Char.IsLower(x.Chars(0)) Then
            ' Capitalize it.
            Return Char.ToUpper(x.Chars(0)) & x.Substring(1, x.Length - 1)
        End If
        Return x
    End Function

    Sub Main()
        Dim text As String = "four score and seven years ago"

        Console.WriteLine($"text=[{text}]")

        Dim rx As New Regex("\w+")

        Dim result As String = rx.Replace(text, AddressOf RegExSample.CapText)

        Console.WriteLine($"result=[{result}]")
    End Sub
End Module
' The example displays the following output:
'       text=[four score and seven years ago]
'       result=[Four Score And Seven Years Ago]

Keterangan

Metode Regex.Replace(String, MatchEvaluator) berguna untuk mengganti kecocokan ekspresi reguler jika salah satu kondisi berikut ini benar:

String pengganti tidak dapat dengan mudah ditentukan oleh pola penggantian ekspresi reguler.
String penggantian dihasilkan dari beberapa pemrosesan yang dilakukan pada string yang cocok.
String penggantian dihasilkan dari pemrosesan bersyarkat.

Metode ini setara dengan memanggil metode Regex.Matches(String) dan meneruskan setiap objek Match dalam koleksi MatchCollection yang dikembalikan ke delegasi evaluator.

Ekspresi reguler adalah pola yang ditentukan oleh konstruktor untuk objek Regex saat ini.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Metode kustom Anda mengembalikan string yang menggantikan input yang cocok.

Lihat juga

MatchEvaluator
Substitusi dalam Ekspresi Reguler
Bahasa Ekspresi Reguler - Referensi Cepat

Berlaku untuk

Replace(String, MatchEvaluator, Int32)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam string input tertentu, mengganti jumlah maksimum string tertentu yang cocok dengan pola ekspresi reguler dengan string yang dikembalikan oleh delegasi MatchEvaluator.

public:
 System::String ^ Replace(System::String ^ input, System::Text::RegularExpressions::MatchEvaluator ^ evaluator, int count);

public string Replace (string input, System.Text.RegularExpressions.MatchEvaluator evaluator, int count);

member this.Replace : string * System.Text.RegularExpressions.MatchEvaluator * int -> string

Public Function Replace (input As String, evaluator As MatchEvaluator, count As Integer) As String

Parameter

input: String

String untuk mencari kecocokan.

evaluator: MatchEvaluator

Metode kustom yang memeriksa setiap kecocokan dan mengembalikan string asli yang cocok atau string pengganti.

count: Int32

Jumlah maksimum kali penggantian akan terjadi.

Mengembalikan

String

Pengecualian

ArgumentNullException

input atau evaluatornull.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Contoh

Contoh berikut menggunakan ekspresi reguler untuk sengaja salah mengeja setengah kata dalam daftar. Ini menggunakan ekspresi reguler \w*(ie|ei)\w* untuk mencocokkan kata-kata yang menyertakan karakter "yaitu" atau "ei". Ini meneruskan paruh pertama kata yang cocok ke metode ReverseLetter, yang, pada gilirannya, menggunakan metode Replace(String, String, String, RegexOptions) untuk membalikkan "i" dan "e" dalam string yang cocok. Kata-kata yang tersisa tetap tidak berubah.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "deceive relieve achieve belief fierce receive";
      string pattern = @"\w*(ie|ei)\w*";
      Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
      Console.WriteLine("Original string: " + input);
      
      string result = rgx.Replace(input, new MatchEvaluator(Example.ReverseLetter), 
                                  input.Split(' ').Length / 2);
      Console.WriteLine("Returned string: " + result);
   }

   static string ReverseLetter(Match match)
   {
      return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase);            
   }
}
// The example displays the following output:
//    Original string: deceive relieve achieve belief fierce receive
//    Returned string: decieve releive acheive belief fierce receive

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "deceive relieve achieve belief fierce receive"
      Dim pattern As String = "\w*(ie|ei)\w*"
      Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
      Console.WriteLine("Original string: " + input)
      
      Dim result As String = rgx.Replace(input, AddressOf ReverseLetter, 
                                           input.Split(" "c).Length \ 2)
      Console.WriteLine("Returned string: " + result)
   End Sub

   Public Function ReverseLetter(match As Match) As String
      Return Regex.Replace(match.Value, "([ie])([ie])", "$2$1", 
                           RegexOptions.IgnoreCase)            
   End Function
End Module
' The example displays the following output:
'    Original string: deceive relieve achieve belief fierce receive
'    Returned string: decieve releive acheive belief fierce receive

Ekspresi reguler \w*(ie|ei)\w* didefinisikan seperti yang diperlihatkan dalam tabel berikut.

Pola	Deskripsi
`\w*`	Cocokkan nol atau lebih karakter kata.
`(ie\|ei)`	Cocokkan "ie" atau "ei".
`\w*`	Cocokkan nol atau lebih karakter kata.

Pola ekspresi reguler ([ie])([ie]) dalam metode ReverseLetter cocok dengan "i" atau "e" pertama dalam diphthong "ie" atau "ei" dan menetapkan huruf ke grup penangkapan pertama. Ini cocok dengan "i" atau "e" kedua dan menetapkan huruf ke grup penangkapan kedua. Kedua karakter kemudian dibalik dengan memanggil metode Replace(String, String, String) dengan pola penggantian $2$1.

Keterangan

Metode Regex.Replace(String, MatchEvaluator, Int32) berguna untuk mengganti kecocokan ekspresi reguler jika salah satu kondisi berikut ini benar:

String pengganti tidak dapat dengan mudah ditentukan oleh pola penggantian ekspresi reguler.
String penggantian dihasilkan dari beberapa pemrosesan yang dilakukan pada string yang cocok.
String penggantian dihasilkan dari pemrosesan bersyarkat.

Metode ini setara dengan memanggil metode Regex.Matches(String) dan meneruskan objek countMatch pertama dalam koleksi MatchCollection yang dikembalikan ke delegasi evaluator.

Ekspresi reguler adalah pola yang ditentukan oleh konstruktor untuk objek Regex saat ini.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Metode kustom Anda mengembalikan string yang menggantikan input yang cocok.

Lihat juga

MatchEvaluator
Substitusi dalam Ekspresi Reguler
Bahasa Ekspresi Reguler - Referensi Cepat

Berlaku untuk

Replace(String, String, MatchEvaluator)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string yang dikembalikan oleh delegasi MatchEvaluator.

public:
 static System::String ^ Replace(System::String ^ input, System::String ^ pattern, System::Text::RegularExpressions::MatchEvaluator ^ evaluator);

public static string Replace (string input, string pattern, System.Text.RegularExpressions.MatchEvaluator evaluator);

static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator -> string

Public Shared Function Replace (input As String, pattern As String, evaluator As MatchEvaluator) As String

Parameter

input: String

String untuk mencari kecocokan.

pattern: String

Pola ekspresi reguler yang cocok.

evaluator: MatchEvaluator

Metode kustom yang memeriksa setiap kecocokan dan mengembalikan string asli yang cocok atau string pengganti.

Mengembalikan

String

Pengecualian

ArgumentException

Terjadi kesalahan penguraian ekspresi reguler.

ArgumentNullException

input, pattern, atau evaluatornull.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Contoh

using System;
using System.Collections;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string words = "letter alphabetical missing lack release " + 
                     "penchant slack acryllic laundry cease";
      string pattern = @"\w+";                            
      MatchEvaluator evaluator = new MatchEvaluator(WordScrambler);
      Console.WriteLine("Original words:");
      Console.WriteLine(words);
      Console.WriteLine();
      Console.WriteLine("Scrambled words:");
      Console.WriteLine(Regex.Replace(words, pattern, evaluator));      
   }

   public static string WordScrambler(Match match)
   {
      int arraySize = match.Value.Length;
      // Define two arrays equal to the number of letters in the match.
      double[] keys = new double[arraySize];
      char[] letters = new char[arraySize];
      
      // Instantiate random number generator'
      Random rnd = new Random();
      
      for (int ctr = 0; ctr < match.Value.Length; ctr++)
      {
         // Populate the array of keys with random numbers.
         keys[ctr] = rnd.NextDouble();
         // Assign letter to array of letters.
         letters[ctr] = match.Value[ctr];
      }         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default);      
      return new String(letters);
   }
}
// The example displays output similar to the following:
//    Original words:
//    letter alphabetical missing lack release penchant slack acryllic laundry cease
//    
//    Scrambled words:
//    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase

Imports System.Collections
Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim words As String = "letter alphabetical missing lack release " + _
                            "penchant slack acryllic laundry cease"
      Dim pattern As String = "\w+"                            
      Dim evaluator As MatchEvaluator = AddressOf WordScrambler
      Console.WriteLine("Original words:")
      Console.WriteLine(words)
      Console.WriteLine("Scrambled words:")
      Console.WriteLine(Regex.Replace(words, pattern, evaluator))      
   End Sub
   
   Public Function WordScrambler(match As Match) As String
      Dim arraySize As Integer = match.Value.Length - 1
      ' Define two arrays equal to the number of letters in the match.
      Dim keys(arraySize) As Double
      Dim letters(arraySize) As Char
      
      ' Instantiate random number generator'
      Dim rnd As New Random()
      
      For ctr As Integer = 0 To match.Value.Length - 1
         ' Populate the array of keys with random numbers.
         keys(ctr) = rnd.NextDouble()
         ' Assign letter to array of letters.
         letters(ctr) = match.Value.Chars(ctr)
      Next         
      Array.Sort(keys, letters, 0, arraySize, Comparer.Default)      
      Return New String(letters)
   End Function
End Module
' The example displays output similar to the following:
'    Original words:
'    letter alphabetical missing lack release penchant slack acryllic laundry cease
'    
'    Scrambled words:
'    elrtte iaeabatlpchl igmnssi lcka aerslee hnpatnce ksacl lialcryc dylruna ecase

Keterangan

Metode Regex.Replace(String, String, MatchEvaluator) berguna untuk mengganti kecocokan ekspresi reguler jika salah satu kondisi berikut ini benar:

String pengganti tidak dapat dengan mudah ditentukan oleh pola penggantian ekspresi reguler.
String penggantian dihasilkan dari beberapa pemrosesan yang dilakukan pada string yang cocok.
String penggantian dihasilkan dari pemrosesan bersyarkat.

Metode ini setara dengan memanggil metode Regex.Matches(String, String) dan meneruskan setiap objek Match dalam koleksi MatchCollection yang dikembalikan ke delegasi evaluator.

public string MatchEvaluatorMethod(Match match)

Public Function MatchEvaluatorMethod(match As Match) As String

Metode kustom Anda mengembalikan string yang menggantikan input yang cocok.

Catatan Bagi Pemanggil

Metode ini kehabisan waktu setelah interval yang sama dengan nilai batas waktu default domain aplikasi di mana ia dipanggil. Jika nilai waktu habis belum ditentukan untuk domain aplikasi, nilai InfiniteMatchTimeout, yang mencegah metode kehabisan waktu, digunakan. Metode statis yang direkomendasikan untuk mengevaluasi dan mengganti kecocokan pola adalah Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), yang memungkinkan Anda mengatur interval waktu habis.

Lihat juga

MatchEvaluator
Substitusi dalam Ekspresi Reguler
Elemen Bahasa Ekspresi Reguler

Berlaku untuk

Replace(String, String, Int32)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam string input tertentu, mengganti jumlah maksimum string tertentu yang cocok dengan pola ekspresi reguler dengan string pengganti yang ditentukan.

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count);

public string Replace (string input, string replacement, int count);

member this.Replace : string * string * int -> string

Public Function Replace (input As String, replacement As String, count As Integer) As String

Parameter

input: String

String untuk mencari kecocokan.

replacement: String

String pengganti.

count: Int32

Berapa kali penggantian dapat terjadi.

Mengembalikan

String

Pengecualian

ArgumentNullException

input atau replacementnull.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Contoh

Contoh berikut menggantikan lima kemunculan pertama karakter duplikat dengan satu karakter. Pola ekspresi reguler (\w)\1 cocok dengan kemunculan berturut-turut dari satu karakter dan menetapkan kemunculan pertama ke grup penangkapan pertama. Pola penggantian $1 menggantikan seluruh kecocokan dengan grup pertama yang diambil.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string str = "aabccdeefgghiijkklmm";
      string pattern = "(\\w)\\1"; 
      string replacement = "$1"; 
      Regex rgx = new Regex(pattern);

      string result = rgx.Replace(str, replacement, 5);
      Console.WriteLine("Original String:    '{0}'", str);
      Console.WriteLine("Replacement String: '{0}'", result); 
   }
}
// The example displays the following output:
//       Original String:    'aabccdeefgghiijkklmm'
//       Replacement String: 'abcdefghijkklmm'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim str As String = "aabccdeefgghiijkklmm"
      Dim pattern As String = "(\w)\1" 
      Dim replacement As String = "$1" 
      Dim rgx As New Regex(pattern)

      Dim result As String = rgx.Replace(str, replacement, 5)
      Console.WriteLine("Original String:    '{0}'", str)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    'aabccdeefgghiijkklmm'
'       Replacement String: 'abcdefghijkklmm'

Keterangan

Pencarian kecocokan dimulai di awal string input. Ekspresi reguler adalah pola yang ditentukan oleh konstruktor untuk objek Regex saat ini. Jika count negatif, penggantian berlanjut ke akhir string. Jika count melebihi jumlah kecocokan, semua kecocokan akan diganti.

Parameter replacement menentukan string yang akan menggantikan kecocokan count pertama di input. replacement dapat terdiri dari kombinasi teks harfiah dan substitusi . Misalnya, pola penggantian a*${test}b menyisipkan string "a*" diikuti dengan substring yang cocok dengan grup penangkapan test, jika ada, diikuti oleh string "b". Karakter * tidak dikenali sebagai metacharacter dalam pola penggantian.

Nota

Lihat juga

Bahasa Ekspresi Reguler - Referensi Cepat
Substitusi dalam Ekspresi Reguler

Berlaku untuk

Replace(String, String)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam string input tertentu, mengganti semua string yang cocok dengan pola ekspresi reguler dengan string pengganti yang ditentukan.

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement);

public string Replace (string input, string replacement);

member this.Replace : string * string -> string

Public Function Replace (input As String, replacement As String) As String

Parameter

input: String

String untuk mencari kecocokan.

replacement: String

String pengganti.

Mengembalikan

String

Pengecualian

ArgumentNullException

input atau replacementnull.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Contoh

Contoh berikut mendefinisikan ekspresi reguler, \s+, yang cocok dengan satu atau beberapa karakter spasi putih. String pengganti, " ", menggantinya dengan karakter spasi tunggal.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "This is   text with   far  too   much   " + 
                     "white space.";
      string pattern = "\\s+";
      string replacement = " ";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);
      
      Console.WriteLine("Original String: {0}", input);
      Console.WriteLine("Replacement String: {0}", result);                             
   }
}
// The example displays the following output:
//       Original String: This is   text with   far  too   much   white space.
//       Replacement String: This is text with far too much white space.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "This is   text with   far  too   much   " + _
                            "white space."
      Dim pattern As String = "\s+"
      Dim replacement As String = " "
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)
      
      Console.WriteLine("Original String: {0}", input)
      Console.WriteLine("Replacement String: {0}", result)                             
   End Sub
End Module
' The example displays the following output:
'          Original String: This is   text with   far  too   much   white space.
'          Replacement String: This is text with far too much white space.

Contoh berikut mendefinisikan ekspresi reguler, (\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?, dan pola penggantian, $2, yang menghapus simbol mata uang di depan atau berikutnya dari nilai numerik.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern =  @"(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?";
      string input = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17";
      string replacement = "$2";
      Regex rgx = new Regex(pattern);
      string result = rgx.Replace(input, replacement);

      Console.WriteLine("Original String:    '{0}'", input);
      Console.WriteLine("Replacement String: '{0}'", result);                             
   }
}
// The example displays the following output:
//       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
//       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim pattern As String =  "(\p{Sc}\s?)?(\d+\.?((?<=\.)\d+)?)(?(1)|\s?\p{Sc})?"
      Dim input As String = "$17.43  €2 16.33  £0.98  0.43   £43   12€  17"
      Dim replacement As String = "$2"
      Dim rgx As New Regex(pattern)
      Dim result As String = rgx.Replace(input, replacement)

      Console.WriteLine("Original String:    '{0}'", input)
      Console.WriteLine("Replacement String: '{0}'", result)                             
   End Sub
End Module
' The example displays the following output:
'       Original String:    '$17.43  €2 16.33  £0.98  0.43   £43   12€  17'
'       Replacement String: '17.43  2 16.33  0.98  0.43   43   12  17'

Ekspresi reguler ditafsirkan seperti yang ditunjukkan dalam tabel berikut.

Pola	Deskripsi
`\p{Sc}`	Cocok dengan simbol mata uang. `{Sc}` menunjukkan karakter apa pun yang merupakan anggota Simbol Unicode, kategori Mata Uang.
`\s?`	Cocokkan nol atau satu karakter spasi putih.
`(\p{Sc}\s?)?`	Cocokkan nol atau satu kemunculan kombinasi simbol mata uang diikuti oleh nol atau satu karakter spasi putih. Ini adalah grup penangkapan pertama.
`\d+`	Cocokkan satu atau beberapa digit desimal.
`\.?`	Cocokkan nol atau satu kemunculan titik (digunakan sebagai karakter pemisah desimal).
`((?<=\.)\d+)?`	Jika titik adalah karakter sebelumnya, cocokkan satu atau beberapa digit desimal. Pola ini dapat dicocokkan dengan nol atau satu kali.
`(\d+\.?((?<=\.)\d+)?)`	Cocokkan pola satu atau beberapa digit desimal diikuti dengan periode opsional dan digit desimal tambahan. Ini adalah grup penangkap kedua. Panggilan ke metode Replace(String, String) menggantikan seluruh kecocokan dengan nilai grup yang diambil ini.
`(?(1)\|\s?\p{Sc})?`	Jika grup pertama yang diambil ada, cocokkan string kosong. Jika tidak, cocokkan nol atau satu karakter spasi putih diikuti dengan simbol mata uang.

Keterangan

Pencarian kecocokan dimulai di awal string input. Ekspresi reguler adalah pola yang ditentukan oleh konstruktor untuk objek Regex saat ini.

Nota

Lihat juga

Bahasa Ekspresi Reguler - Referensi Cepat
Substitusi dalam Ekspresi Reguler

Berlaku untuk

Replace(String, String, Int32, Int32)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam substring input tertentu, menggantikan jumlah maksimum string tertentu yang cocok dengan pola ekspresi reguler dengan string pengganti yang ditentukan.

public:
 System::String ^ Replace(System::String ^ input, System::String ^ replacement, int count, int startat);

public string Replace (string input, string replacement, int count, int startat);

member this.Replace : string * string * int * int -> string

Public Function Replace (input As String, replacement As String, count As Integer, startat As Integer) As String

Parameter

input: String

String untuk mencari kecocokan.

replacement: String

String pengganti.

count: Int32

Berapa kali penggantian dapat terjadi.

startat: Int32

Posisi karakter dalam string input tempat pencarian dimulai.

Mengembalikan

String

Pengecualian

ArgumentNullException

input atau replacementnull.

ArgumentOutOfRangeException

startat kurang dari nol atau lebih besar dari panjang input.

RegexMatchTimeoutException

Waktu habis terjadi. Untuk informasi selengkapnya tentang waktu habis, lihat bagian Keterangan.

Contoh

Contoh berikut meng-spasi ganda semua kecuali baris pertama string. Ini mendefinisikan pola ekspresi reguler, ^.*$, yang cocok dengan baris teks, memanggil metode Match(String) untuk mencocokkan baris pertama string, dan menggunakan properti Match.Index dan Match.Count untuk menentukan posisi awal baris kedua.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string input = "Instantiating a New Type\n" +
                     "Generally, there are two ways that an\n" + 
                     "instance of a class or structure can\n" +
                     "be instantiated. ";
      string pattern = "^.*$";
      string replacement = "\n$&";
      Regex rgx = new Regex(pattern, RegexOptions.Multiline);
      string result = String.Empty; 
      
      Match match = rgx.Match(input);
      // Double space all but the first line.
      if (match.Success) 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1);

      Console.WriteLine(result);                     
   }
}
// The example displays the following output:
//       Instantiating a New Type
//       
//       Generally, there are two ways that an
//       
//       instance of a class or structure can
//       
//       be instntiated.

Imports System.Text.RegularExpressions

Module Example
   Public Sub Main()
      Dim input As String = "Instantiating a New Type" + vbCrLf + _
                            "Generally, there are two ways that an" + vbCrLf + _
                            "instance of a class or structure can" + vbCrLf + _
                            "be instantiated. "
      Dim pattern As String = "^.*$"
      Dim replacement As String = vbCrLf + "$&"
      Dim rgx As New Regex(pattern, RegexOptions.Multiline)
      Dim result As String = String.Empty 
      
      Dim match As Match = rgx.Match(input)
      ' Double space all but the first line.
      If match.Success Then 
         result = rgx.Replace(input, replacement, -1, match.Index + match.Length + 1)
      End If
      Console.WriteLine(result)                      
   End Sub
End Module
' The example displays the following output:
'       Instantiating a New Type
'       
'       Generally, there are two ways that an
'       
'       instance of a class or structure can
'       
'       be instntiated.

Pola ekspresi reguler ^.*$ didefinisikan seperti yang diperlihatkan dalam tabel berikut.

Pola	Deskripsi
`^`	Cocokkan awal baris. (Perhatikan bahwa objek Regex dibuat dengan menggunakan opsi RegexOptions.Multiline; jika tidak, kelas karakter ini hanya akan cocok dengan awal string input.)
`.*`	Cocokkan karakter apa pun nol atau lebih kali.
`$`	Cocokkan akhir baris. (Perhatikan bahwa objek Regex dibuat dengan menggunakan opsi RegexOptions.Multiline; jika tidak, kelas karakter ini hanya akan cocok dengan awal string input.)

String pengganti (vbCrLf + "$&" di Visual Basic, "\n$&" di C#) menambahkan baris baru sebelum string yang cocok. Perhatikan bahwa \n dalam contoh C# ditafsirkan sebagai karakter baris baru oleh pengkompilasi C#; ini tidak mewakili escape karakter ekspresi reguler.

Keterangan

Pencarian kecocokan dimulai dalam string input pada posisi yang ditentukan oleh parameter startat. Ekspresi reguler adalah pola yang ditentukan oleh konstruktor untuk objek Regex saat ini. Jika count negatif, penggantian berlanjut ke akhir string. Jika count melebihi jumlah kecocokan, semua kecocokan akan diganti.

Untuk detail selengkapnya tentang startat, lihat bagian Keterangan dari Match(String, Int32).

Nota

Lihat juga

Substitusi dalam Ekspresi Reguler
Bahasa Ekspresi Reguler - Referensi Cepat

Berlaku untuk

Bagikan melalui

Regex.Replace Metode

Definisi

Overload

Replace(String, MatchEvaluator, Int32, Int32)

Parameter

Mengembalikan

Pengecualian

Keterangan

Lihat juga

Berlaku untuk

Replace(String, String, String)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Replace(String, String, MatchEvaluator, RegexOptions)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Replace(String, String, String, RegexOptions, TimeSpan)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Replace(String, String, String, RegexOptions)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk

Replace(String, MatchEvaluator)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Replace(String, MatchEvaluator, Int32)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Lihat juga

Berlaku untuk

Replace(String, String, MatchEvaluator)

Parameter

Mengembalikan

Pengecualian

Contoh

Keterangan

Catatan Bagi Pemanggil

Lihat juga

Berlaku untuk