Kelas System.Text.RegularExpressions.Regex

Artikel ini menyediakan keterangan tambahan untuk dokumentasi referensi untuk API ini.

Kelas Regex mewakili . Mesin regex NET. Anda dapat menggunakan kelas ini untuk:

• Mengurai teks dalam jumlah besar dengan cepat untuk menemukan pola karakter tertentu.
• Ekstrak, edit, ganti, atau hapus substring teks.
• Tambahkan string yang diekstrak ke koleksi untuk menghasilkan laporan.

Catatan

Jika Anda ingin memvalidasi string dengan menentukan apakah string tersebut sesuai dengan pola ekspresi reguler tertentu, Anda dapat menggunakan System.Configuration.RegexStringValidator kelas .

Untuk menggunakan ekspresi reguler, Anda menentukan pola yang ingin Anda identifikasi dalam aliran teks dengan menggunakan sintaks yang didokumenkan dalam bahasa ekspresi Reguler - referensi cepat. Selanjutnya, Anda dapat secara opsional membuat instans Regex objek. Terakhir, Anda memanggil metode yang melakukan beberapa operasi, seperti mengganti teks yang cocok dengan pola ekspresi reguler, atau mengidentifikasi kecocokan pola.

Untuk informasi selengkapnya tentang bahasa ekspresi reguler, lihat Bahasa ekspresi reguler - referensi cepat atau unduh dan cetak salah satu brosur ini:

Referensi Cepat dalam formatWord (.docx) Format Referensi Cepat dalam format PDF (.pdf)

Metode Regex vs. String

Kelas ini System.String mencakup beberapa metode pencarian dan perbandingan yang dapat Anda gunakan untuk melakukan pencocokan pola dengan teks. Misalnya, String.Containsmetode , String.EndsWith, dan String.StartsWith menentukan apakah instans string berisi substring tertentu; dan String.IndexOfmetode , , String.LastIndexOfString.IndexOfAny, dan String.LastIndexOfAny mengembalikan posisi awal substring tertentu dalam string. Gunakan metode System.String kelas saat Anda mencari string tertentu. Regex Gunakan kelas saat Anda mencari pola tertentu dalam string. Untuk informasi dan contoh selengkapnya, lihat .NET Regular Expressions.

Metode instans statis vs.

Setelah menentukan pola ekspresi reguler, Anda dapat menyediakannya ke mesin ekspresi reguler dengan salah satu dari dua cara:

• Dengan membuat Regex instans objek yang mewakili ekspresi reguler. Untuk melakukan ini, Anda meneruskan pola ekspresi reguler ke Regex konstruktor. Objek Regex tidak dapat diubah; saat Anda membuat instans Regex objek dengan ekspresi reguler, ekspresi reguler objek tersebut tidak dapat diubah.

• Dengan menyediakan ekspresi reguler dan teks untuk mencari ke static metode (Shared dalam Visual Basic). Regex Ini memungkinkan Anda menggunakan ekspresi reguler tanpa membuat Regex objek secara eksplisit.

Semua Regex metode identifikasi pola mencakup kelebihan beban statis dan instans.

Mesin ekspresi reguler harus mengkompilasi pola tertentu sebelum pola dapat digunakan. Karena Regex objek tidak dapat diubah, ini adalah prosedur satu kali yang terjadi ketika Regex konstruktor kelas atau metode statis dipanggil. Untuk menghilangkan kebutuhan untuk berulang kali mengkompilasi ekspresi reguler tunggal, mesin ekspresi reguler menyimpan cache ekspresi reguler yang dikompilasi yang digunakan dalam panggilan metode statis. Akibatnya, metode pencocokan pola ekspresi reguler menawarkan performa yang sebanding untuk metode statis dan instans. Namun, penembolokan dapat berdampak buruk pada performa dalam dua kasus berikut:

• Saat Anda menggunakan panggilan metode statis dengan sejumlah besar ekspresi reguler. Secara default, mesin ekspresi reguler menyimpan 15 ekspresi reguler statis yang terakhir digunakan. Jika aplikasi Anda menggunakan lebih dari 15 ekspresi reguler statis, beberapa ekspresi reguler harus dikompresi ulang. Untuk mencegah kompilasi ulang ini, Anda dapat meningkatkan Regex.CacheSize properti .

• Saat Anda membuat instans objek baru Regex dengan ekspresi reguler yang sebelumnya telah dikompilasi. Misalnya, kode berikut menentukan ekspresi reguler untuk menemukan kata-kata duplikat dalam aliran teks. Meskipun contoh menggunakan ekspresi reguler tunggal, contoh ini membuat instans objek baru Regex untuk memproses setiap baris teks. Ini menghasilkan kompilasi ulang ekspresi reguler dengan setiap iterasi perulangan.

  StreamReader sr = new StreamReader(filename);
  string input;
  string pattern = @"\b(\w+)\s\1\b";
  while (sr.Peek() >= 0)
  {
     input = sr.ReadLine();
     Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
     MatchCollection matches = rgx.Matches(input);
     if (matches.Count > 0)
     {
        Console.WriteLine("{0} ({1} matches):", input, matches.Count);
        foreach (Match match in matches)
           Console.WriteLine("   " + match.Value);
     }
  }
  sr.Close();
  

  Dim sr As New StreamReader(filename)
  Dim input As String
  Dim pattern As String = "\b(\w+)\s\1\b"
  Do While sr.Peek() >= 0
     input = sr.ReadLine()
     Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
     Dim matches As MatchCollection = rgx.Matches(input)
     If matches.Count > 0 Then
        Console.WriteLine("{0} ({1} matches):", input, matches.Count)
        For Each match As Match In matches
           Console.WriteLine("   " + match.Value)
        Next   
     End If
  Loop
  sr.Close()
  

  Untuk mencegah kompilasi ulang, Anda harus membuat instans satu Regex objek yang dapat diakses oleh semua kode yang memerlukannya, seperti yang ditunjukkan dalam contoh yang ditulis ulang berikut.

  StreamReader sr = new StreamReader(filename);
  string input;
  string pattern = @"\b(\w+)\s\1\b";
  Regex rgx = new Regex(pattern, RegexOptions.IgnoreCase);
  
  while (sr.Peek() >= 0)
  {
     input = sr.ReadLine();
     MatchCollection matches = rgx.Matches(input);
     if (matches.Count > 0)
     {
        Console.WriteLine("{0} ({1} matches):", input, matches.Count);
        foreach (Match match in matches)
           Console.WriteLine("   " + match.Value);
     }
  }
  sr.Close();
  

  Dim sr As New StreamReader(filename)
  Dim input As String
  Dim pattern As String = "\b(\w+)\s\1\b"
  Dim rgx As New Regex(pattern, RegexOptions.IgnoreCase)
  Do While sr.Peek() >= 0
     input = sr.ReadLine()
     Dim matches As MatchCollection = rgx.Matches(input)
     If matches.Count > 0 Then
        Console.WriteLine("{0} ({1} matches):", input, matches.Count)
        For Each match As Match In matches
           Console.WriteLine("   " + match.Value)
        Next   
     End If
  Loop
  sr.Close()
  

Melakukan operasi ekspresi reguler

Apakah Anda memutuskan untuk membuat instans Regex objek dan memanggil metodenya atau memanggil metode statis, Regex kelas menawarkan fungsionalitas pencocokan pola berikut:

• Validasi kecocokan. Anda memanggil metode untuk menentukan apakah ada kecocokan IsMatch .

• Pengambilan satu kecocokan. Anda memanggil Match metode untuk mengambil Match objek yang mewakili kecocokan pertama dalam string atau di bagian string. Kecocokan berikutnya dapat diambil dengan memanggil Match.NextMatch metode .

• Pengambilan semua kecocokan. Anda memanggil Matches metode untuk mengambil System.Text.RegularExpressions.MatchCollection objek yang mewakili semua kecocokan yang ditemukan dalam string atau di bagian string.

• Penggantian teks yang cocok. Anda memanggil Replace metode untuk mengganti teks yang cocok. Teks pengganti juga dapat ditentukan oleh ekspresi reguler. Selain itu, beberapa Replace metode menyertakan MatchEvaluator parameter yang memungkinkan Anda menentukan teks pengganti secara terprogram.

• Pembuatan array string yang dibentuk dari bagian string input. Anda memanggil Split metode untuk membagi string input pada posisi yang ditentukan oleh ekspresi reguler.

Selain metode pencocokan polanya, Regex kelas ini mencakup beberapa metode tujuan khusus:

• Metode ini Escape lolos dari karakter apa pun yang dapat ditafsirkan sebagai operator ekspresi reguler dalam ekspresi reguler atau string input.
• Metode Unescape menghapus karakter escape ini.
• Metode ini CompileToAssembly membuat rakitan yang berisi ekspresi reguler yang telah ditentukan sebelumnya. .NET berisi contoh rakitan tujuan khusus ini di System.Web.RegularExpressions namespace.

Tentukan nilai batas waktu

.NET mendukung bahasa ekspresi reguler berfitur lengkap yang memberikan daya dan fleksibilitas besar dalam pencocokan pola. Namun, daya dan fleksibilitas dikenakan biaya: risiko performa yang buruk. Ekspresi reguler yang berkinerja buruk sangat mudah dibuat. Dalam beberapa kasus, operasi ekspresi reguler yang mengandalkan backtracking yang berlebihan dapat tampak berhenti merespons ketika mereka memproses teks yang hampir cocok dengan pola ekspresi reguler. Untuk informasi selengkapnya tentang mesin .NET Regular Expression, lihat Detail perilaku ekspresi reguler. Untuk informasi selengkapnya tentang backtracking yang berlebihan, lihat Backtracking.

Dimulai dengan .NET Framework 4.5, Anda dapat menentukan interval waktu habis untuk kecocokan ekspresi reguler untuk membatasi backtracking yang berlebihan. Bergantung pada pola ekspresi reguler dan teks input, waktu eksekusi dapat melebihi interval waktu habis yang ditentukan, tetapi tidak akan menghabiskan lebih banyak waktu untuk mundur daripada interval waktu habis yang ditentukan. Jika mesin ekspresi reguler kehabisan waktu, mesin ekspresi akan melemparkan RegexMatchTimeoutException pengecualian. Dalam kebanyakan kasus, ini mencegah mesin ekspresi reguler membuang-buang daya pemrosesan dengan mencoba mencocokkan teks yang hampir cocok dengan pola ekspresi reguler. Namun, ini juga dapat menunjukkan bahwa interval waktu habis telah diatur terlalu rendah, atau bahwa beban komputer saat ini telah menyebabkan penurunan performa secara keseluruhan.

Cara Anda menangani pengecualian tergantung pada penyebab pengecualian. Jika pengecualian terjadi karena interval waktu habis diatur terlalu rendah atau karena beban komputer yang berlebihan, Anda dapat meningkatkan interval waktu habis dan mencoba kembali operasi yang cocok. Jika pengecualian terjadi karena ekspresi reguler bergantung pada backtracking yang berlebihan, Anda dapat mengasumsikan bahwa kecocokan tidak ada, dan, secara opsional, Anda dapat mencatat informasi yang akan membantu Anda mengubah pola ekspresi reguler.

Anda dapat mengatur interval waktu habis dengan memanggil Regex(String, RegexOptions, TimeSpan) konstruktor saat Membuat instans objek ekspresi reguler. Untuk metode statis, Anda dapat mengatur interval waktu habis dengan memanggil kelebihan beban metode pencocokan yang memiliki matchTimeout parameter. Jika Anda tidak menetapkan nilai time-out secara eksplisit, nilai time-out default ditentukan sebagai berikut:

• Dengan memakai nilai time-out di seluruh aplikasi, jika ada. Atur nilai batas waktu di seluruh aplikasi dengan memanggil AppDomain.SetData metode untuk menetapkan representasi TimeSpan string nilai ke REGEX_DEFAULT_MATCH_TIMEOUT properti .
• Dengan menggunakan nilai InfiniteMatchTimeout, jika tidak ada nilai time-out di seluruh aplikasi yang ditetapkan.

Penting

Kami menyarankan agar Anda menetapkan nilai batas waktu di semua operasi pencocokan pola ekspresi reguler. Untuk informasi selengkapnya, lihat Praktik terbaik untuk ekspresi reguler.

Contoh

Contoh berikut menggunakan ekspresi reguler untuk memeriksa kemunculan kata berulang dalam string. Ekspresi \b(?<word>\w+)\s+(\k<word>)\b reguler dapat ditafsirkan seperti yang ditunjukkan dalam tabel berikut.

Pola	Deskripsi
\b	Mulai kecocokan pada batas kata.
(?<word>\w+)	Cocokkan satu atau beberapa karakter kata hingga batas kata. Beri nama grup wordyang diambil ini .
\s+	Cocokkan satu atau beberapa karakter white space.
(\k<word>)	Cocokkan grup yang diambil yang bernama word.
\b	Cocokkan batas kata.

using System;
using System.Text.RegularExpressions;

public class Test
{
    public static void Main ()
    {
        // Define a regular expression for repeated words.
        Regex rx = new Regex(@"\b(?<word>\w+)\s+(\k<word>)\b",
          RegexOptions.Compiled | RegexOptions.IgnoreCase);

        // Define a test string.
        string text = "The the quick brown fox  fox jumps over the lazy dog dog.";

        // Find matches.
        MatchCollection matches = rx.Matches(text);

        // Report the number of matches found.
        Console.WriteLine("{0} matches found in:\n   {1}",
                          matches.Count,
                          text);

        // Report on each match.
        foreach (Match match in matches)
        {
            GroupCollection groups = match.Groups;
            Console.WriteLine("'{0}' repeated at positions {1} and {2}",
                              groups["word"].Value,
                              groups[0].Index,
                              groups[1].Index);
        }
    }
}

// The example produces the following output to the console:
//       3 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'The' repeated at positions 0 and 4
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 49 and 53

Imports System.Text.RegularExpressions

Public Module Test

    Public Sub Main()
        ' Define a regular expression for repeated words.
        Dim rx As New Regex("\b(?<word>\w+)\s+(\k<word>)\b", _
               RegexOptions.Compiled Or RegexOptions.IgnoreCase)

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches.
        Dim matches As MatchCollection = rx.Matches(text)

        ' Report the number of matches found.
        Console.WriteLine("{0} matches found in:", matches.Count)
        Console.WriteLine("   {0}", text)

        ' Report on each match.
        For Each match As Match In matches
            Dim groups As GroupCollection = match.Groups
            Console.WriteLine("'{0}' repeated at positions {1} and {2}", _ 
                              groups.Item("word").Value, _
                              groups.Item(0).Index, _
                              groups.Item(1).Index)
        Next
    End Sub
End Module
' The example produces the following output to the console:
'       3 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'The' repeated at positions 0 and 4
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 49 and 53

Contoh berikutnya mengilustrasikan penggunaan ekspresi reguler untuk memeriksa apakah string mewakili nilai mata uang atau memiliki format yang benar untuk mewakili nilai mata uang. Dalam hal ini, ekspresi reguler dibangun secara dinamis dari NumberFormatInfo.CurrencyDecimalSeparatorproperti , , CurrencyDecimalDigits, NumberFormatInfo.NegativeSignNumberFormatInfo.CurrencySymbol, dan NumberFormatInfo.PositiveSign untuk budaya en-US. Ekspresi reguler yang dihasilkan adalah ^\s*[\+-]?\s?\$?\s?(\d*\.?\d{2}?){1}$. Ekspresi reguler ini dapat ditafsirkan seperti yang ditunjukkan dalam tabel berikut.

Pola	Deskripsi
^	Mulai di awal string.
\s*	Cocokkan nol atau lebih karakter spasi kosong.
[\+-]?	Cocokkan nol atau satu kemunculan tanda positif atau tanda negatif.
\s?	Cocokkan nol atau satu karakter white space.
\$?	Cocokkan nol atau satu kemunculan tanda dolar.
\s?	Cocokkan nol atau satu karakter white space.
\d*	Cocokkan satu atau beberapa angka desimal.
\.?	Cocokkan nol atau satu simbol titik desimal.
(\d{2})?	Menangkap grup 1: Cocokkan dua digit desimal nol atau satu kali.
(\d*\.?(\d{2})?){1}	Cocokkan pola digit integral dan pecahan yang dipisahkan oleh simbol koma desimal setidaknya satu kali.
$	Cocokkan akhir string.

Dalam hal ini, ekspresi reguler mengasumsikan bahwa string mata uang yang valid tidak berisi simbol pemisah grup, dan tidak memiliki digit pecahan atau jumlah digit pecahan yang ditentukan oleh properti budaya CurrencyDecimalDigits yang ditentukan.

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

public class Example
{
    public static void Main()
    {
        // Get the en-US NumberFormatInfo object to build the regular 
        // expression pattern dynamically.
        NumberFormatInfo nfi = CultureInfo.GetCultureInfo("en-US").NumberFormat;

        // Define the regular expression pattern.
        string pattern;
        pattern = @"^\s*[";
        // Get the positive and negative sign symbols.
        pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + @"]?\s?";
        // Get the currency symbol.
        pattern += Regex.Escape(nfi.CurrencySymbol) + @"?\s?";
        // Add integral digits to the pattern.
        pattern += @"(\d*";
        // Add the decimal separator.
        pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?";
        // Add the fractional digits.
        pattern += @"(\d{";
        // Determine the number of fractional digits in currency values.
        pattern += nfi.CurrencyDecimalDigits.ToString() + "})?){1}$";

        Console.WriteLine($"Pattern is {pattern}\n");

        Regex rgx = new Regex(pattern);

        // Define some test strings.
        string[] tests = { "-42", "19.99", "0.001", "100 USD",
                         ".34", "0.34", "1,052.21", "$10.62",
                         "+1.43", "-$0.23" };

        // Check each test string against the regular expression.
        foreach (string test in tests)
        {
            if (rgx.IsMatch(test))
                Console.WriteLine($"{test} is a currency value.");
            else
                Console.WriteLine($"{test} is not a currency value.");
        }
    }
}
// The example displays the following output:
//       Pattern is ^\s*[\+-]?\s?\$?\s?(\d*\.?(\d{2})?){1}$
//
//       -42 is a currency value.
//       19.99 is a currency value.
//       0.001 is not a currency value.
//       100 USD is not a currency value.
//       .34 is a currency value.
//       0.34 is a currency value.
//       1,052.21 is not a currency value.
//       $10.62 is a currency value.
//       +1.43 is a currency value.
//       -$0.23 is a currency value.

Imports System.Globalization
Imports System.Text.RegularExpressions

Public Module Example
   Public Sub Main()
      ' Get the current NumberFormatInfo object to build the regular 
      ' expression pattern dynamically.
      Dim nfi As NumberFormatInfo = CultureInfo.GetCultureInfo("en-US").NumberFormat

      ' Define the regular expression pattern.
      Dim pattern As String 
      pattern = "^\s*["
      ' Get the positive and negative sign symbols.
      pattern += Regex.Escape(nfi.PositiveSign + nfi.NegativeSign) + "]?\s?"
      ' Get the currency symbol.
      pattern += Regex.Escape(nfi.CurrencySymbol) + "?\s?"
      ' Add integral digits to the pattern.
      pattern += "(\d*"
      ' Add the decimal separator.
      pattern += Regex.Escape(nfi.CurrencyDecimalSeparator) + "?"
      ' Add the fractional digits.
      pattern += "(\d{"
      ' Determine the number of fractional digits in currency values.
      pattern += nfi.CurrencyDecimalDigits.ToString() + "})?){1}$"
      
      Console.WriteLine("Pattern is {0}", pattern)
      Console.WriteLine()
      
      Dim rgx As New Regex(pattern)

      ' Define some test strings.
      Dim tests() As String = {"-42", "19.99", "0.001", "100 USD", _
                               ".34", "0.34", "1,052.21", "$10.62", _
                               "+1.43", "-$0.23" }

      ' Check each test string against the regular expression.
      For Each test As String In tests
         If rgx.IsMatch(test) Then
            Console.WriteLine("{0} is a currency value.", test)
         Else
            Console.WriteLine("{0} is not a currency value.", test)
         End If
      Next
   End Sub
End Module
' The example displays the following output:
'       Pattern is ^\s*[\+-]?\s?\$?\s?(\d*\.?(\d{2})?){1}$
'
'       -42 is a currency value.
'       19.99 is a currency value.
'       0.001 is not a currency value.
'       100 USD is not a currency value.
'       .34 is a currency value.
'       0.34 is a currency value.
'       1,052.21 is not a currency value.
'       $10.62 is a currency value.
'       +1.43 is a currency value.
'       -$0.23 is a currency value.

Karena ekspresi reguler dalam contoh ini dibangun secara dinamis, Anda tidak tahu pada waktu desain apakah simbol mata uang, tanda desimal, atau tanda positif dan negatif dari budaya yang ditentukan (en-US dalam contoh ini) mungkin disalahartikan oleh mesin ekspresi reguler sebagai operator bahasa ekspresi reguler. Untuk mencegah salah menafsirkan, contoh meneruskan setiap string yang dihasilkan secara dinamis ke Escape metode .