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, menggantikan jumlah maksimum string tertentu yang cocok dengan pola ekspresi reguler dengan string yang MatchEvaluator dikembalikan oleh delegasi.
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, menggantikan semua substring yang cocok dengan ekspresi reguler tertentu dengan string yang MatchEvaluator dikembalikan oleh delegasi. 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 MatchEvaluator dikembalikan oleh delegasi. 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 MatchEvaluator dikembalikan oleh delegasi.
Replace(String, MatchEvaluator, Int32)	Dalam string input tertentu, menggantikan jumlah maksimum string tertentu yang cocok dengan pola ekspresi reguler dengan string yang MatchEvaluator dikembalikan oleh delegasi.
Replace(String, String, MatchEvaluator)	Dalam string input tertentu, mengganti semua string yang cocok dengan ekspresi reguler tertentu dengan string yang MatchEvaluator dikembalikan oleh delegasi.
Replace(String, String, Int32)	Dalam string input tertentu, menggantikan 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, menggantikan jumlah maksimum string tertentu yang cocok dengan pola ekspresi reguler dengan string yang MatchEvaluator dikembalikan oleh delegasi.

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 yang tidak berubah.

Pengecualian

ArgumentNullException

input atau evaluator adalah null.

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) ini 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 pengganti dihasilkan dari beberapa pemrosesan yang dilakukan pada string yang cocok.
String penggantian dihasilkan dari pemrosesan bersyarkat.

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

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

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

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 MatchEvaluator delegasi.

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 Regex.Regex(String, RegexOptions, TimeSpan) konstruktor. Jika Anda tidak mengatur interval waktu habis saat Memanggil konstruktor, pengecualian akan dilemparkan jika operasi melebihi nilai batas waktu yang ditetapkan untuk domain aplikasi tempat Regex objek dibuat. Jika tidak ada waktu habis yang didefinisikan dalam Regex panggilan konstruktor atau di properti domain aplikasi, atau jika nilai waktu habis adalah Regex.InfiniteMatchTimeout, tidak ada pengecualian yang dilemparkan

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

Lihat juga

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 regex 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 replacement adalah null.

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 Replace(String, String, String) metode untuk mengganti nama komputer lokal dan drive di jalur UNC dengan jalur file lokal. Ekspresi reguler menggunakan Environment.MachineName properti untuk menyertakan nama komputer lokal, dan Environment.GetLogicalDrives metode 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 menunjukkan bagaimana pola regex 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 Environment.MachineName properti .
`(?:\.\w+)*`	Cocok dengan 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 tidak sensitif 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 $1 pengganti menggantikan seluruh kecocokan dengan subekspresi pertama yang diambil. Artinya, ia menggantikan komputer UNC dan nama drive dengan huruf kandar.

Keterangan

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

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

Catatan

Substitusi adalah satu-satunya elemen bahasa ekspresi reguler yang dikenali dalam pola penggantian. Semua elemen bahasa ekspresi reguler lainnya, termasuk pelarian karakter, 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 waktu habis adalah 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

Berlaku untuk

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

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam string input tertentu, menggantikan semua substring yang cocok dengan ekspresi reguler tertentu dengan string yang MatchEvaluator dikembalikan oleh delegasi. Parameter tambahan menentukan opsi yang memodifikasi operasi yang cocok 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 regex 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 evaluator adalah null.

ArgumentOutOfRangeException

options bukan kombinasi RegexOptions nilai bitwise yang valid.

-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 MatchEvaluator delegasi untuk memanggil metode bernama WordScramble yang mengacak huruf individual dalam kata. Untuk melakukan ini, WordScramble metode membuat array yang berisi karakter dalam kecocokan. Ini juga membuat array paralel yang diisinya dengan angka floating-point acak. Array diurutkan dengan memanggil Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) metode , dan array yang diurutkan disediakan sebagai argumen ke String konstruktor kelas. String yang baru dibuat ini kemudian dikembalikan oleh WordScramble metode . Pola \w+ ekspresi reguler 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 Replace(String, String, MatchEvaluator, RegexOptions) metode menyertakan RegexOptions.IgnorePatternWhitespace opsi sehingga komentar dalam pola \w+ # Matches all the characters in a word. ekspresi reguler 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) ini 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 Regex.Matches(String, String, RegexOptions) metode dan meneruskan setiap Match objek dalam koleksi yang dikembalikan MatchCollection ke evaluator delegasi.

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 parameter options , pencarian kecocokan dimulai di akhir string input dan bergerak ke kiri; jika tidak, pencarian dimulai di 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 RegexMatchTimeoutException pengecualian. matchTimeout mengambil alih nilai batas waktu default yang ditentukan untuk domain aplikasi tempat metode dijalankan.

Catatan Bagi Pemanggil

Kami menyarankan agar Anda mengatur parameter ke matchTimeout 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 waktu habis 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 tersebut secara efisien menangani kecocokan, non-kecocokan, dan hampir kecocokan.
Ketika pola ekspresi reguler tidak berisi elemen bahasa yang diketahui menyebabkan backtracking yang berlebihan saat memproses kecocokan dekat.

Lihat juga

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 MatchEvaluator dikembalikan oleh delegasi. 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 regex 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 evaluator adalah null.

ArgumentOutOfRangeException

options bukan kombinasi RegexOptions nilai bitwise yang valid.

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) ini 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 pengganti hasil dari beberapa pemrosesan yang dilakukan pada string yang cocok.
String penggantian dihasilkan dari pemrosesan bersyarah.

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

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 yang cocok 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 regex 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 replacement adalah null.

ArgumentOutOfRangeException

options bukan kombinasi RegexOptions nilai bitwise yang valid.

-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 Replace(String, String, String, RegexOptions, TimeSpan) metode untuk mengganti nama komputer lokal dan drive di jalur UNC dengan jalur file lokal. Ekspresi reguler menggunakan Environment.MachineName properti untuk menyertakan nama komputer lokal dan Environment.GetLogicalDrives metode untuk menyertakan nama drive logis. Semua perbandingan string ekspresi reguler tidak peka huruf besar/kecil, dan setiap waktu operasi penggantian tunggal habis jika kecocokan tidak dapat ditemukan dalam 0,5 detik. Untuk menjalankan contoh dengan sukses, 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 menunjukkan bagaimana pola regex 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 +`	Cocok dengan string yang dikembalikan oleh Environment.MachineName properti .
`(?:\.\w+)*`	Cocok dengan karakter titik (`.`) diikuti oleh satu atau beberapa karakter kata. Kecocokan ini dapat terjadi nol atau lebih kali. Subekspresi yang cocok tidak ditangkap.
`\\`	Cocokkan karakter garis miring terbelakang (`\`).
`([" + driveNames + "])`	Cocokkan kelas karakter yang terdiri dari huruf drive individual. Kecocokan ini adalah subekspresi pertama yang diambil.
`\$`	Cocokkan karakter tanda dolar harfiah (`$`).

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

Keterangan

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

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 parameter options , pencarian kecocokan dimulai di akhir string input dan bergerak ke kiri; jika tidak, pencarian dimulai di awal string input dan bergerak ke kanan.

Catatan

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 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 RegexMatchTimeoutException pengecualian. 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 tersebut secara efisien menangani kecocokan, non-kecocokan, dan hampir kecocokan.
Ketika pola ekspresi reguler tidak berisi elemen bahasa yang diketahui menyebabkan backtracking yang berlebihan saat memproses kecocokan dekat.

Lihat juga

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 regex 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 replacement adalah null.

ArgumentOutOfRangeException

options bukan kombinasi RegexOptions nilai bitwise yang valid.

RegexMatchTimeoutException

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

Contoh

Contoh berikut menggunakan Replace(String, String, String, RegexOptions) metode untuk mengganti nama komputer lokal dan drive di jalur UNC dengan jalur file lokal. Ekspresi reguler menggunakan Environment.MachineName properti untuk menyertakan nama komputer lokal, dan Environment.GetLogicalDrives metode untuk menyertakan nama drive logis. Semua perbandingan string ekspresi reguler tidak peka huruf besar/kecil. Untuk menjalankan contoh dengan sukses, 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 menunjukkan bagaimana pola regex 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 +`	Cocok dengan string yang dikembalikan oleh Environment.MachineName properti .
`(?:\.\w+)*`	Cocok dengan karakter titik (`.`) diikuti oleh satu atau beberapa karakter kata. Kecocokan ini dapat terjadi nol atau lebih kali. Subekspresi yang cocok tidak ditangkap.
`\\`	Cocokkan karakter garis miring terbelakang (`\`).
`([" + driveNames + "])`	Cocokkan kelas karakter yang terdiri dari huruf drive individual. Kecocokan ini adalah subekspresi pertama yang diambil.
`\$`	Cocokkan karakter tanda dolar harfiah (`$`).

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

Keterangan

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

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

Catatan

Substitusi adalah satu-satunya elemen bahasa ekspresi reguler yang dikenali dalam pola pengganti. Semua elemen bahasa ekspresi reguler lainnya, termasuk escape karakter, 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 didefinisikan dalam properti domain aplikasi, atau jika nilai waktu habis adalah 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 tempatnya dipanggil. Jika nilai waktu habis belum ditentukan untuk domain aplikasi, nilai InfiniteMatchTimeout, yang mencegah waktu habis metode 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

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 MatchEvaluator dikembalikan oleh delegasi.

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 evaluator adalah null.

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) ini 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 pengganti dihasilkan dari beberapa pemrosesan yang dilakukan pada string yang cocok.
String penggantian dihasilkan dari pemrosesan bersyarkat.

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

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

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, MatchEvaluator, Int32)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

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

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 evaluator adalah null.

RegexMatchTimeoutException

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

Contoh

Contoh berikut menggunakan ekspresi reguler untuk sengaja salah mengeja setengah dari kata-kata dalam daftar. Ini menggunakan ekspresi \w*(ie|ei)\w* reguler untuk mencocokkan kata-kata yang menyertakan karakter "ie" atau "ei". Ini melewati paruh pertama kata-kata yang cocok ke ReverseLetter metode , yang, pada gilirannya Replace(String, String, String, RegexOptions) , menggunakan metode 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

Regex \w*(ie|ei)\w* didefinisikan seperti yang ditunjukkan dalam tabel berikut.

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

Pola ([ie])([ie]) ekspresi reguler dalam ReverseLetter metode cocok dengan "i" atau "e" pertama di 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 tersebut kemudian dibalik dengan memanggil Replace(String, String, String) metode dengan pola $2$1pengganti .

Keterangan

Metode Regex.Replace(String, MatchEvaluator, Int32) ini 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 pengganti dihasilkan dari beberapa pemrosesan yang dilakukan pada string yang cocok.
String penggantian dihasilkan dari pemrosesan bersyarkat.

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

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

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, 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 MatchEvaluator dikembalikan oleh delegasi.

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 regex 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 evaluator adalah null.

RegexMatchTimeoutException

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

Contoh

Contoh berikut menggunakan ekspresi reguler untuk mengekstrak kata-kata individual dari string, lalu menggunakan MatchEvaluator delegasi untuk memanggil metode bernama WordScramble yang mengacak huruf individual dalam kata. Untuk melakukan ini, WordScramble metode membuat array yang berisi karakter dalam kecocokan. Ini juga membuat array paralel yang diisi dengan angka floating-point acak. Array diurutkan dengan memanggil Array.Sort<TKey,TValue>(TKey[], TValue[], IComparer<TKey>) metode , dan array yang diurutkan disediakan sebagai argumen ke String konstruktor kelas. String yang baru dibuat ini kemudian dikembalikan oleh WordScramble metode . Pola \w+ ekspresi reguler 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.

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) ini 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 pengganti dihasilkan dari beberapa pemrosesan yang dilakukan pada string yang cocok.
String penggantian dihasilkan dari pemrosesan bersyarkat.

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

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 untuk domain aplikasi tempat metode dipanggil. Jika tidak ada waktu habis yang didefinisikan dalam properti domain aplikasi, atau jika nilai waktu habis adalah 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 mengevaluasi dan mengganti kecocokan pola adalah Replace(String, String, MatchEvaluator, RegexOptions, TimeSpan), yang memungkinkan Anda mengatur interval waktu habis.

Lihat juga

Berlaku untuk

Replace(String, String, Int32)

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Sumber:: Regex.Replace.cs

Dalam string 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);

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

Jumlah maksimum kali penggantian dapat terjadi.

Mengembalikan

String

Pengecualian

ArgumentNullException

input atau replacement adalah null.

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 (\w)\1 ekspresi reguler cocok dengan kemunculan berturut-turut dari satu karakter dan menetapkan kemunculan pertama ke grup penangkapan pertama. Pola $1 pengganti menggantikan seluruh kecocokan dengan grup pertama yang ditangkap.

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 input string. Ekspresi reguler adalah pola yang ditentukan oleh konstruktor untuk objek saat ini Regex . 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 pertama count di input. replacement dapat terdiri dari kombinasi teks harfiah dan substitusi. Misalnya, pola a*${test}b pengganti menyisipkan string "a*" diikuti dengan substring yang dicocokkan oleh test grup penangkapan, jika ada, diikuti oleh string "b". Karakter * tidak dikenali sebagai metacharacter dalam pola pengganti.

Catatan

Lihat juga

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 replacement adalah null.

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 pengganti, $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'

Regex ditafsirkan seperti yang diperlihatkan dalam tabel berikut ini.

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 white space.
`(\p{Sc}\s?)?`	Cocokkan nol atau satu kemunculan kombinasi simbol mata uang diikuti oleh nol atau satu karakter spasi putih. Ini adalah grup pengambilan pertama.
`\d+`	Cocokkan satu atau beberapa angka desimal.
`\.?`	Cocokkan nol atau satu kemunculan titik (digunakan sebagai karakter pemisah desimal).
`((?<=\.)\d+)?`	Jika titik adalah karakter sebelumnya, cocok dengan satu atau beberapa digit desimal. Pola ini dapat dicocokkan baik nol atau satu kali.
`(\d+\.?((?<=\.)\d+)?)`	Cocokkan pola satu atau beberapa digit desimal diikuti dengan periode opsional dan digit desimal tambahan. Ini adalah grup pengambilan kedua. Panggilan ke Replace(String, String) metode menggantikan seluruh kecocokan dengan nilai grup yang ditangkap 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 input string. Ekspresi reguler adalah pola yang ditentukan oleh konstruktor untuk objek saat ini Regex .

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

Catatan

Lihat juga

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 replacement adalah null.

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 mengalihkan spasi ganda semua kecuali baris pertama string. Ini mendefinisikan pola ekspresi reguler, ^.*$, yang cocok dengan baris teks, memanggil Match(String) metode untuk mencocokkan baris pertama string, dan menggunakan Match.Index properti 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 regex ^.*$ didefinisikan seperti yang ditunjukkan pada tabel berikut.

Pola	Deskripsi
`^`	Cocokkan awal baris. (Perhatikan bahwa Regex objek dibuat dengan menggunakan RegexOptions.Multiline opsi ; 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 Regex objek dibuat dengan menggunakan RegexOptions.Multiline opsi ; 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#; itu tidak mewakili escape karakter ekspresi reguler.

Keterangan

Pencarian kecocokan dimulai dalam input string pada posisi yang ditentukan oleh startat parameter . Ekspresi reguler adalah pola yang ditentukan oleh konstruktor untuk objek saat ini Regex . 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).

Catatan

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

Lihat juga

Berlaku untuk