Opsi regex

Artikel
06/20/2024

Secara default, perbandingan string input dengan karakter literal apa pun dalam pola ekspresi reguler peka huruf besar/kecil dalam pola ekspresi reguler ditafsirkan sebagai karakter spasi putih harfiah, dan menangkap grup dalam ekspresi reguler dinamai secara implisit serta secara eksplisit. Anda dapat memodifikasi ini dan beberapa aspek lain dari perilaku regex default dengan menentukan opsi regex. Beberapa opsi ini, yang tercantum dalam tabel berikut, dapat disertakan sebaris sebagai bagian dari pola regex, atau dapat diberikan ke konstruktor kelas System.Text.RegularExpressions.Regex atau metode pencocokan pola statik sebagai nilai enumerasi System.Text.RegularExpressions.RegexOptions.

`RegexOptions` anggota	Karakter sebaris	Efek	Informasi selengkapnya
None	Tidak tersedia	Gunakan perilaku default.	Opsi default
IgnoreCase	`i`	Gunakan pencocokan tidak peka huruf besar/kecil.	Pencocokan tidak peka huruf besar/kecil
Multiline	`m`	Gunakan mode multibaris, di mana `^` dan `$` tunjukkan awal dan akhir setiap baris (bukan awal dan akhir string input).	Mode multibaris
Singleline	`s`	Gunakan mode satu baris, di mana titik (.) cocok dengan setiap karakter (bukan setiap karakter kecuali `\n`).	Mode baris tunggal
ExplicitCapture	`n`	Jangan ambil grup tanpa nama. Satu-satunya tangkapan yang valid secara eksplisit bernama atau bernomor dari subekspresi`)` nama`>` formulir.`(?<`	Pengambilan eksplisit saja
Compiled	Tidak tersedia	Kompilasi regex ke assembly.	Ekspresi reguler yang dikompilasi
IgnorePatternWhitespace	`x`	Kecualikan spasi kosong yang tidak di-escape dari pola, dan aktifkan komentar setelah tanda angka (`#`).	Abaikan spasi kosong
RightToLeft	Tidak tersedia	Ubah arah pencarian. Pencarian bergerak dari kanan ke kiri, bukan dari kiri ke kanan.	Mode kanan-ke-kiri
ECMAScript	Tidak tersedia	Aktifkan perilaku yang sesuai dengan ECMAScript untuk ekspresi.	Perilaku pencocokan ECMAScript
CultureInvariant	Tidak tersedia	Abaikan perbedaan kultur dalam bahasa.	Perbandingan menggunakan budaya invarian
NonBacktracking	Tidak tersedia	Cocokkan menggunakan pendekatan yang menghindari pelacakan balik dan menjamin pemrosesan waktu linier dalam panjang input. (Tersedia di .NET 7 dan versi yang lebih baru.)	Mode non-tracking

Menentukan opsi

Anda dapat menentukan opsi untuk regex dengan salah satu dari tiga cara:

Dalam parameter options dari konstruktor kelas System.Text.RegularExpressions.Regex atau metode pencocokan pola statis (Shared dalam Visual Basic), seperti Regex(String, RegexOptions) atau Regex.Match(String, String, RegexOptions). Parameter options adalah kombinasi OR bitwise dari nilai enumerasi System.Text.RegularExpressions.RegexOptions.

Saat opsi diberikan ke instans Regex menggunakan parameter options dari konstruktor kelas, opsi ditetapkan ke properti System.Text.RegularExpressions.RegexOptions. Namun, properti System.Text.RegularExpressions.RegexOptions tidak mencerminkan opsi sebaris dalam pola regex itu sendiri.

Contoh berikut memberikan ilustrasi. Ini menggunakan parameter options dari metode Regex.Match(String, String, RegexOptions) untuk mengaktifkan pencocokan yang tidak peka huruf besar/kecil dan mengabaikan pola spasi kosong saat mengidentifikasi kata yang dimulai dengan huruf "d".
```
string pattern = @"d \w+ \s";
string input = "Dogs are decidedly good pets.";
RegexOptions options = RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace;

foreach (Match match in Regex.Matches(input, pattern, options))
    Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.
```
```
Dim pattern As String = "d \w+ \s"
Dim input As String = "Dogs are decidedly good pets."
Dim options As RegexOptions = RegexOptions.IgnoreCase Or RegexOptions.IgnorePatternWhitespace

For Each match As Match In Regex.Matches(input, pattern, options)
    Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      
```

Dengan menerapkan opsi sebaris dalam pola regex dengan sintaks (?imnsx-imnsx). Opsi berlaku untuk pola dari titik di mana opsi ditentukan ke akhir pola atau ke titik di mana opsi tidak ditentukan oleh opsi sebaris lainnya. Perhatikan bahwa properti System.Text.RegularExpressions.RegexOptions dari instans Regex tidak mencerminkan opsi sebaris ini. Untuk informasi selengkapnya, lihat Konstruksi Lain-Lain.

Contoh berikut memberikan ilustrasi. Ini menggunakan opsi sebaris untuk mengaktifkan pencocokan yang tidak peka huruf besar-kecil dan mengabaikan pola spasi kosong saat mengidentifikasi kata-kata yang dimulai dengan huruf "d".

string pattern = @"(?ix) d \w+ \s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
    Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.

Dim pattern As String = "\b(?ix) d \w+ \s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
    Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.

Dengan menerapkan opsi sebaris dalam konstruksi pengelompokan tertentu dalam pola regex dengan sintaks (?imnsx-imnsx:subekspresi). Tidak ada tanda sebelum satu set opsi mengaktifkan set; tanda minus sebelum satu set opsi menonaktifkan set. (? adalah bagian tetap dari sintaks konstruksi bahasa yang diperlukan, terlepas dari apakah opsi diaktifkan atau dinonaktifkan.) Opsi hanya berlaku untuk grup tersebut. Untuk informasi selengkapnya, lihat Konstruksi Pengelompokan.

Contoh berikut memberikan ilustrasi. Ini menggunakan opsi sebaris dalam konstruksi pengelompokan untuk mengaktifkan pencocokan yang tidak peka huruf besar-kecil dan mengabaikan pola spasi kosong saat mengidentifikasi kata-kata yang dimulai dengan huruf "d".
```
string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";

foreach (Match match in Regex.Matches(input, pattern))
    Console.WriteLine("'{0}// found at index {1}.", match.Value, match.Index);
// The example displays the following output:
//    'Dogs // found at index 0.
//    'decidedly // found at index 9.
```
```
Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."

For Each match As Match In Regex.Matches(input, pattern)
    Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
'    'Dogs ' found at index 0.
'    'decidedly ' found at index 9.      
```

Jika opsi ditentukan sebaris, tanda minus (-) sebelum opsi atau kumpulan opsi akan menonaktifkan opsi tersebut. Misalnya, konstruksi sebaris (?ix-ms) mengaktifkan opsi RegexOptions.IgnoreCase dan RegexOptions.IgnorePatternWhitespace serta menonaktifkan opsi RegexOptions.Multiline dan RegexOptions.Singleline. Semua opsi regex dinonaktifkan secara default.

Catatan

Jika opsi regex yang ditentukan dalam parameter options konstruktor atau panggilan metode bertentangan dengan opsi yang ditentukan sebaris dalam pola regex, opsi sebaris akan digunakan.

Lima opsi regex berikut dapat diatur dengan sebaris dan parameter opsi:

Lima opsi regex berikut dapat diatur menggunakan parameter options, tetapi tidak dapat diatur sebaris:

Menentukan opsi

Anda dapat menentukan opsi mana yang disediakan untuk objek Regex saat ini dibuat dengan mengambil nilai properti Regex.Options baca-saja.

Untuk menguji keberadaan opsi apa pun kecuali RegexOptions.None, lakukan operasi AND dengan nilai properti Regex.Options dan nilai RegexOptions yang Anda minati. Kemudian uji apakah hasilnya sama dengan nilai RegexOptions tersebut. Contoh berikut menguji apakah opsi RegexOptions.IgnoreCase telah diatur.

if ((rgx.Options & RegexOptions.IgnoreCase) == RegexOptions.IgnoreCase)
    Console.WriteLine("Case-insensitive pattern comparison.");
else
    Console.WriteLine("Case-sensitive pattern comparison.");

If (rgx.Options And RegexOptions.IgnoreCase) = RegexOptions.IgnoreCase Then
    Console.WriteLine("Case-insensitive pattern comparison.")
Else
    Console.WriteLine("Case-sensitive pattern comparison.")
End If

Untuk menguji RegexOptions.None, tentukan apakah nilai properti Regex.Options sama dengan RegexOptions.None, seperti yang diilustrasikan pada contoh berikut.

if (rgx.Options == RegexOptions.None)
    Console.WriteLine("No options have been set.");

If rgx.Options = RegexOptions.None Then
    Console.WriteLine("No options have been set.")
End If

Bagian berikut mencantumkan opsi yang didukung oleh regex di .NET.

Opsi default

Opsi RegexOptions.None menunjukkan bahwa tidak ada opsi yang ditentukan, dan mesin regex menggunakan perilaku defaultnya. Ini termasuk yang berikut:

Pola ini ditafsirkan sebagai kanonis, dan bukan regex ECMAScript.
Pola regex dicocokkan dalam string input dari kiri ke kanan.
Perbandingan sifatnya peka huruf besar/kecil.
Elemen ^ bahasa dan $ menunjukkan awal dan akhir string input. Akhir dari string input dapat berupa karakter \n baris baru berikutnya.
Elemen bahasa . cocok dengan setiap karakter kecuali \n.
Setiap spasi kosong dalam pola regex ditafsirkan sebagai karakter spasi harfiah.
Konvensi kultur saat ini digunakan saat membandingkan pola dengan string input.
Grup penangkapan dalam pola regex bersifat implisit dan juga eksplisit.

Catatan

Opsi RegexOptions.None tidak memiliki padanan sebaris. Saat opsi regex diterapkan sebaris, perilaku default dipulihkan berdasarkan opsi demi opsi, dengan menonaktifkan opsi tertentu. Misalnya, (?i) mengaktifkan perbandingan yang tidak peka huruf besar/kecil, dan (?-i) memulihkan perbandingan peka huruf besar/kecil default.

Karena opsi RegexOptions.None mewakili perilaku default mesin regex, opsi ini jarang ditentukan secara eksplisit dalam pemanggilan metode. Sebagai gantinya, konstruktor atau metode pencocokan pola statis tanpa parameter options dipanggil.

Pencocokan yang peka huruf besar/kecil

Opsi IgnoreCase, atau opsi sebaris i, memberikan pencocokan yang tidak peka huruf besar/kecil. Secara default, konvensi casing dari kultur saat ini digunakan.

Contoh berikut mendefinisikan pola regex, \bthe\w*\b, yang cocok dengan semua kata yang dimulai dengan "the". Karena panggilan pertama ke metode Match menggunakan perbandingan peka huruf besar/kecil default, output menunjukkan bahwa string "The" yang memulai kalimat tidak cocok. Ini cocok ketika metode Match dipanggil dengan opsi yang diatur ke IgnoreCase.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bthe\w*\b";
      string input = "The man then told them about that event.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern,
                                            RegexOptions.IgnoreCase))
         Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
   }
}
// The example displays the following output:
//       Found then at index 8.
//       Found them at index 18.
//
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\bthe\w*\b"
        Dim input As String = "The man then told them about that event."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
        Next
        Console.WriteLine()
        For Each match As Match In Regex.Matches(input, pattern, _
                                                 RegexOptions.IgnoreCase)
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       Found then at index 8.
'       Found them at index 18.
'       
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.

Contoh berikut memodifikasi pola regex dari contoh sebelumnya untuk menggunakan opsi sebaris alih-alih parameter options untuk memberikan perbandingan peka huruf besar/kecil. Pola pertama mendefinisikan opsi yang tidak peka huruf besar/kecil dalam konstruksi pengelompokan yang hanya berlaku untuk huruf "t" dalam string "the". Karena konstruksi opsi terjadi di awal pola, pola kedua menerapkan opsi yang tidak peka huruf besar/kecil ke seluruh regex.

using System;
using System.Text.RegularExpressions;

public class CaseExample
{
    public static void Main()
    {
        string pattern = @"\b(?i:t)he\w*\b";
        string input = "The man then told them about that event.";
        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);

        Console.WriteLine();
        pattern = @"(?i)\bthe\w*\b";
        foreach (Match match in Regex.Matches(input, pattern,
                                              RegexOptions.IgnoreCase))
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index);
    }
}
// The example displays the following output:
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.
//
//       Found The at index 0.
//       Found then at index 8.
//       Found them at index 18.

Imports System.Text.RegularExpressions

Module CaseExample
    Public Sub Main()
        Dim pattern As String = "\b(?i:t)he\w*\b"
        Dim input As String = "The man then told them about that event."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
        Next
        Console.WriteLine()
        pattern = "(?i)\bthe\w*\b"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("Found {0} at index {1}.", match.Value, match.Index)
        Next
    End Sub
End Module

' The example displays the following output:
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.
'       
'       Found The at index 0.
'       Found then at index 8.
'       Found them at index 18.

Mode multibaris

Opsi RegexOptions.Multiline, atau opsi sebaris m, memungkinkan mesin regex menangani string input yang terdiri dari beberapa baris. Ini mengubah interpretasi ^ elemen bahasa dan $ sehingga menunjukkan awal dan akhir baris, bukan awal dan akhir string input.

Secara default, $ hanya akan terpenuhi di akhir string input. Jika Anda menentukan RegexOptions.Multiline opsi , opsi tersebut akan dipenuhi oleh karakter baris baru (\n) atau akhir string input.

Dalam kedua kasus tidak $ mengenali kombinasi\r\n karakter pengembalian/umpan baris (). $ selalu mengabaikan pengembalian pengangkutan apa pun (\r). Untuk mengakhiri kecocokan Anda dengan atau \r\n \n, gunakan subekspresi \r?$ alih-alih hanya $. Perhatikan bahwa ini akan membuat \r bagian dari pertandingan.

Contoh berikut mengekstrak nama dan skor bowler dan menambahkannya ke koleksi SortedList<TKey,TValue> yang mengurutkannya dalam urutan menurun. Matches Metode ini disebutkan dua kali. Dalam pemanggilan metode pertama, regex adalah ^(\w+)\s(\d+)$ dan tidak ada opsi yang diatur. Seperti yang ditunjukkan oleh output, karena mesin regex tidak dapat mencocokkan pola input beserta awal dan akhir string input, tidak ada kecocokan yang ditemukan. Dalam pemanggilan metode kedua, regex diubah menjadi ^(\w+)\s(\d+)\r?$ dan opsi diatur ke RegexOptions.Multiline. Seperti yang ditunjukkan output, nama dan skor berhasil dicocokkan, dan skor ditampilkan dalam urutan menurun.

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

public class Multiline1Example
{
    public static void Main()
    {
        SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer1<int>());

        string input = "Joe 164\n" +
                       "Sam 208\n" +
                       "Allison 211\n" +
                       "Gwen 171\n";
        string pattern = @"^(\w+)\s(\d+)$";
        bool matched = false;

        Console.WriteLine("Without Multiline option:");
        foreach (Match match in Regex.Matches(input, pattern))
        {
            scores.Add(Int32.Parse(match.Groups[2].Value), (string)match.Groups[1].Value);
            matched = true;
        }
        if (!matched)
            Console.WriteLine("   No matches.");
        Console.WriteLine();

        // Redefine pattern to handle multiple lines.
        pattern = @"^(\w+)\s(\d+)\r*$";
        Console.WriteLine("With multiline option:");
        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
            scores.Add(Int32.Parse(match.Groups[2].Value), (string)match.Groups[1].Value);

        // List scores in descending order.
        foreach (KeyValuePair<int, string> score in scores)
            Console.WriteLine("{0}: {1}", score.Value, score.Key);
    }
}

public class DescendingComparer1<T> : IComparer<T>
{
    public int Compare(T x, T y)
    {
        return Comparer<T>.Default.Compare(x, y) * -1;
    }
}
// The example displays the following output:
//   Without Multiline option:
//      No matches.
//
//   With multiline option:
//   Allison: 211
//   Sam: 208
//   Gwen: 171
//   Joe: 164

Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Multiline1Example
    Public Sub Main()
        Dim scores As New SortedList(Of Integer, String)(New DescendingComparer1(Of Integer)())

        Dim input As String = "Joe 164" + vbCrLf +
                              "Sam 208" + vbCrLf +
                              "Allison 211" + vbCrLf +
                              "Gwen 171" + vbCrLf
        Dim pattern As String = "^(\w+)\s(\d+)$"
        Dim matched As Boolean = False

        Console.WriteLine("Without Multiline option:")
        For Each match As Match In Regex.Matches(input, pattern)
            scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
            matched = True
        Next
        If Not matched Then Console.WriteLine("   No matches.")
        Console.WriteLine()

        ' Redefine pattern to handle multiple lines.
        pattern = "^(\w+)\s(\d+)\r*$"
        Console.WriteLine("With multiline option:")
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
            scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
        Next
        ' List scores in descending order. 
        For Each score As KeyValuePair(Of Integer, String) In scores
            Console.WriteLine("{0}: {1}", score.Value, score.Key)
        Next
    End Sub
End Module

Public Class DescendingComparer1(Of T) : Implements IComparer(Of T)
    Public Function Compare(x As T, y As T) As Integer _
           Implements IComparer(Of T).Compare
        Return Comparer(Of T).Default.Compare(x, y) * -1
    End Function
End Class
' The example displays the following output:
'    Without Multiline option:
'       No matches.
'    
'    With multiline option:
'    Allison: 211
'    Sam: 208
'    Gwen: 171
'    Joe: 164

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

Pola	Deskripsi
`^`	Mulai dari awal baris.
`(\w+)`	Mencocokkan satu atau beberapa karakter kata. Ini adalah grup penangkapan pertama.
`\s`	Cocokkan karakter spasi kosong.
`(\d+)`	Cocokkan satu atau beberapa angka desimal. Ini adalah grup pengambilan kedua.
`\r?`	Cocokkan nol atau satu karakter kembali ke awal.
`$`	Berakhir di akhir baris.

Contoh berikut ini sama dengan yang sebelumnya, hanya saja contoh ini menggunakan opsi sebaris (?m) untuk mengatur opsi multibaris.

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

public class Multiline2Example
{
    public static void Main()
    {
        SortedList<int, string> scores = new SortedList<int, string>(new DescendingComparer<int>());

        string input = "Joe 164\n" +
                       "Sam 208\n" +
                       "Allison 211\n" +
                       "Gwen 171\n";
        string pattern = @"(?m)^(\w+)\s(\d+)\r*$";

        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Multiline))
            scores.Add(Convert.ToInt32(match.Groups[2].Value), match.Groups[1].Value);

        // List scores in descending order.
        foreach (KeyValuePair<int, string> score in scores)
            Console.WriteLine("{0}: {1}", score.Value, score.Key);
    }
}

public class DescendingComparer<T> : IComparer<T>
{
    public int Compare(T x, T y)
    {
        return Comparer<T>.Default.Compare(x, y) * -1;
    }
}
// The example displays the following output:
//    Allison: 211
//    Sam: 208
//    Gwen: 171
//    Joe: 164

Imports System.Collections.Generic
Imports System.Text.RegularExpressions

Module Multiline2Example
    Public Sub Main()
        Dim scores As New SortedList(Of Integer, String)(New DescendingComparer(Of Integer)())

        Dim input As String = "Joe 164" + vbCrLf +
                              "Sam 208" + vbCrLf +
                              "Allison 211" + vbCrLf +
                              "Gwen 171" + vbCrLf
        Dim pattern As String = "(?m)^(\w+)\s(\d+)\r*$"

        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.Multiline)
            scores.Add(CInt(match.Groups(2).Value), match.Groups(1).Value)
        Next
        ' List scores in descending order. 
        For Each score As KeyValuePair(Of Integer, String) In scores
            Console.WriteLine("{0}: {1}", score.Value, score.Key)
        Next
    End Sub
End Module

Public Class DescendingComparer(Of T) : Implements IComparer(Of T)
    Public Function Compare(x As T, y As T) As Integer _
           Implements IComparer(Of T).Compare
        Return Comparer(Of T).Default.Compare(x, y) * -1
    End Function
End Class
' The example displays the following output:
'    Allison: 211
'    Sam: 208
'    Gwen: 171
'    Joe: 164

Mode baris tunggal

Opsi RegexOptions.Singleline, atau opsi sebaris s, menyebabkan mesin regex memperlakukan string input seolah-olah terdiri dari satu baris. Ini dilakukan dengan mengubah perilaku elemen bahasa titik (.) sehingga cocok dengan setiap karakter, alih-alih mencocokkan setiap karakter kecuali untuk karakter \nbaris baru .

Contoh berikut mengilustrasikan bagaimana perilaku elemen bahasa . berubah saat Anda menggunakan opsi RegexOptions.Singleline. Regex ^.+ dimulai di awal string dan cocok dengan setiap karakter. Secara default, kecocokan berakhir di akhir baris pertama; pola ekspresi reguler cocok dengan karakter \rpengembalian pengangkutan , tetapi tidak cocok \ndengan . Karena opsi RegexOptions.Singleline menafsirkan seluruh string input sebagai satu baris, opsi ini cocok dengan setiap karakter dalam string input, termasuk \n.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = "^.+";
      string input = "This is one line and" + Environment.NewLine + "this is the second.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(Regex.Escape(match.Value));

      Console.WriteLine();
      foreach (Match match in Regex.Matches(input, pattern, RegexOptions.Singleline))
         Console.WriteLine(Regex.Escape(match.Value));
   }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r
//
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^.+"
        Dim input As String = "This is one line and" + vbCrLf + "this is the second."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(Regex.Escape(match.Value))
        Next
        Console.WriteLine()
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.SingleLine)
            Console.WriteLine(Regex.Escape(match.Value))
        Next
    End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r
'       
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Contoh berikut ini sama dengan yang sebelumnya, hanya saja contoh ini menggunakan opsi sebaris (?s) untuk mengaktifkan mode satu baris.

using System;
using System.Text.RegularExpressions;

public class SingleLineExample
{
    public static void Main()
    {
        string pattern = "(?s)^.+";
        string input = "This is one line and" + Environment.NewLine + "this is the second.";

        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine(Regex.Escape(match.Value));
    }
}
// The example displays the following output:
//       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Imports System.Text.RegularExpressions

Module SingleLineExample
    Public Sub Main()
        Dim pattern As String = "(?s)^.+"
        Dim input As String = "This is one line and" + vbCrLf + "this is the second."

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(Regex.Escape(match.Value))
        Next
    End Sub
End Module
' The example displays the following output:
'       This\ is\ one\ line\ and\r\nthis\ is\ the\ second\.

Hanya pengambilan eksplisit

Secara default, grup pengambilan ditentukan oleh penggunaan tanda kurung dalam pola regex. Grup bernama diberi nama atau nomor dengan opsi bahasa (?<nama>subekspresi), sedangkan grup tanpa nama dapat diakses dengan indeks. Di objek GroupCollection, grup tanpa nama mendahului grup bernama.

Konstruksi pengelompokan sering digunakan hanya untuk menerapkan kuantifier ke beberapa elemen bahasa, dan substring yang diambil tidak menjadi perhatian. Misalnya, jika regex berikut:

\b$?((\w+),?\s?)+[\.!?]$?

dimaksudkan hanya untuk mengekstrak kalimat yang diakhiri dengan titik, tanda seru, atau tanda tanya dari suatu dokumen, hanya kalimat yang dihasilkan (yang diwakili oleh objek Match) yang menjadi perhatian. Masing-masing kata dalam koleksi tidak menjadi perhatian.

Grup penangkapan yang kemudian tidak digunakan bisa mahal, karena mesin regex harus mengisi objek koleksi GroupCollection dan CaptureCollection. Sebagai alternatif, Anda dapat menggunakan opsi atau opsi sebaris untuk menentukan bahwa satu-satunya tangkapan yang valid secara eksplisit diberi nama atau grup bernomor yang ditunjuk oleh (?<konstruksi subekspresi) nama>.n RegexOptions.ExplicitCapture

Contoh berikut menampilkan informasi tentang kecocokan yang dikembalikan oleh pola regex \b$?((\w+),?\s?)+[\.!?]$? saat metode Match dipanggil dengan dan tanpa opsi RegexOptions.ExplicitCapture. Seperti yang ditunjukkan oleh output dari pemanggilan metode pertama, mesin regex mengisi sepenuhnya objek koleksi GroupCollection dan CaptureCollection dengan informasi tentang substring yang diambil. Karena metode kedua dipanggil dengan options diatur ke RegexOptions.ExplicitCapture, metode ini tidak menangkap informasi tentang grup.

using System;
using System.Text.RegularExpressions;

public class Explicit1Example
{
    public static void Main()
    {
        string input = "This is the first sentence. Is it the beginning " +
                       "of a literary masterpiece? I think not. Instead, " +
                       "it is a nonsensical paragraph.";
        string pattern = @"\b\(?((?>\w+),?\s?)+[\.!?]\)?";
        Console.WriteLine("With implicit captures:");
        foreach (Match match in Regex.Matches(input, pattern))
        {
            Console.WriteLine("The match: {0}", match.Value);
            int groupCtr = 0;
            foreach (Group group in match.Groups)
            {
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
                groupCtr++;
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
                    captureCtr++;
                }
            }
        }
        Console.WriteLine();
        Console.WriteLine("With explicit captures only:");
        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.ExplicitCapture))
        {
            Console.WriteLine("The match: {0}", match.Value);
            int groupCtr = 0;
            foreach (Group group in match.Groups)
            {
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
                groupCtr++;
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
                    captureCtr++;
                }
            }
        }
    }
}
// The example displays the following output:
//    With implicit captures:
//    The match: This is the first sentence.
//       Group 0: This is the first sentence.
//          Capture 0: This is the first sentence.
//       Group 1: sentence
//          Capture 0: This
//          Capture 1: is
//          Capture 2: the
//          Capture 3: first
//          Capture 4: sentence
//       Group 2: sentence
//          Capture 0: This
//          Capture 1: is
//          Capture 2: the
//          Capture 3: first
//          Capture 4: sentence
//    The match: Is it the beginning of a literary masterpiece?
//       Group 0: Is it the beginning of a literary masterpiece?
//          Capture 0: Is it the beginning of a literary masterpiece?
//       Group 1: masterpiece
//          Capture 0: Is
//          Capture 1: it
//          Capture 2: the
//          Capture 3: beginning
//          Capture 4: of
//          Capture 5: a
//          Capture 6: literary
//          Capture 7: masterpiece
//       Group 2: masterpiece
//          Capture 0: Is
//          Capture 1: it
//          Capture 2: the
//          Capture 3: beginning
//          Capture 4: of
//          Capture 5: a
//          Capture 6: literary
//          Capture 7: masterpiece
//    The match: I think not.
//       Group 0: I think not.
//          Capture 0: I think not.
//       Group 1: not
//          Capture 0: I
//          Capture 1: think
//          Capture 2: not
//       Group 2: not
//          Capture 0: I
//          Capture 1: think
//          Capture 2: not
//    The match: Instead, it is a nonsensical paragraph.
//       Group 0: Instead, it is a nonsensical paragraph.
//          Capture 0: Instead, it is a nonsensical paragraph.
//       Group 1: paragraph
//          Capture 0: Instead,
//          Capture 1: it
//          Capture 2: is
//          Capture 3: a
//          Capture 4: nonsensical
//          Capture 5: paragraph
//       Group 2: paragraph
//          Capture 0: Instead
//          Capture 1: it
//          Capture 2: is
//          Capture 3: a
//          Capture 4: nonsensical
//          Capture 5: paragraph
//
//    With explicit captures only:
//    The match: This is the first sentence.
//       Group 0: This is the first sentence.
//          Capture 0: This is the first sentence.
//    The match: Is it the beginning of a literary masterpiece?
//       Group 0: Is it the beginning of a literary masterpiece?
//          Capture 0: Is it the beginning of a literary masterpiece?
//    The match: I think not.
//       Group 0: I think not.
//          Capture 0: I think not.
//    The match: Instead, it is a nonsensical paragraph.
//       Group 0: Instead, it is a nonsensical paragraph.
//          Capture 0: Instead, it is a nonsensical paragraph.

Imports System.Text.RegularExpressions

Module Explicit1Example
    Public Sub Main()
        Dim input As String = "This is the first sentence. Is it the beginning " +
                              "of a literary masterpiece? I think not. Instead, " +
                              "it is a nonsensical paragraph."
        Dim pattern As String = "\b\(?((?>\w+),?\s?)+[\.!?]\)?"
        Console.WriteLine("With implicit captures:")
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("The match: {0}", match.Value)
            Dim groupCtr As Integer = 0
            For Each group As Group In match.Groups
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
                groupCtr += 1
                Dim captureCtr As Integer = 0
                For Each capture As Capture In group.Captures
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
                    captureCtr += 1
                Next
            Next
        Next
        Console.WriteLine()
        Console.WriteLine("With explicit captures only:")
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.ExplicitCapture)
            Console.WriteLine("The match: {0}", match.Value)
            Dim groupCtr As Integer = 0
            For Each group As Group In match.Groups
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
                groupCtr += 1
                Dim captureCtr As Integer = 0
                For Each capture As Capture In group.Captures
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
                    captureCtr += 1
                Next
            Next
        Next
    End Sub
End Module
' The example displays the following output:
'    With implicit captures:
'    The match: This is the first sentence.
'       Group 0: This is the first sentence.
'          Capture 0: This is the first sentence.
'       Group 1: sentence
'          Capture 0: This
'          Capture 1: is
'          Capture 2: the
'          Capture 3: first
'          Capture 4: sentence
'       Group 2: sentence
'          Capture 0: This
'          Capture 1: is
'          Capture 2: the
'          Capture 3: first
'          Capture 4: sentence
'    The match: Is it the beginning of a literary masterpiece?
'       Group 0: Is it the beginning of a literary masterpiece?
'          Capture 0: Is it the beginning of a literary masterpiece?
'       Group 1: masterpiece
'          Capture 0: Is
'          Capture 1: it
'          Capture 2: the
'          Capture 3: beginning
'          Capture 4: of
'          Capture 5: a
'          Capture 6: literary
'          Capture 7: masterpiece
'       Group 2: masterpiece
'          Capture 0: Is
'          Capture 1: it
'          Capture 2: the
'          Capture 3: beginning
'          Capture 4: of
'          Capture 5: a
'          Capture 6: literary
'          Capture 7: masterpiece
'    The match: I think not.
'       Group 0: I think not.
'          Capture 0: I think not.
'       Group 1: not
'          Capture 0: I
'          Capture 1: think
'          Capture 2: not
'       Group 2: not
'          Capture 0: I
'          Capture 1: think
'          Capture 2: not
'    The match: Instead, it is a nonsensical paragraph.
'       Group 0: Instead, it is a nonsensical paragraph.
'          Capture 0: Instead, it is a nonsensical paragraph.
'       Group 1: paragraph
'          Capture 0: Instead,
'          Capture 1: it
'          Capture 2: is
'          Capture 3: a
'          Capture 4: nonsensical
'          Capture 5: paragraph
'       Group 2: paragraph
'          Capture 0: Instead
'          Capture 1: it
'          Capture 2: is
'          Capture 3: a
'          Capture 4: nonsensical
'          Capture 5: paragraph
'    
'    With explicit captures only:
'    The match: This is the first sentence.
'       Group 0: This is the first sentence.
'          Capture 0: This is the first sentence.
'    The match: Is it the beginning of a literary masterpiece?
'       Group 0: Is it the beginning of a literary masterpiece?
'          Capture 0: Is it the beginning of a literary masterpiece?
'    The match: I think not.
'       Group 0: I think not.
'          Capture 0: I think not.
'    The match: Instead, it is a nonsensical paragraph.
'       Group 0: Instead, it is a nonsensical paragraph.
'          Capture 0: Instead, it is a nonsensical paragraph.

Pola regex \b$?((?>\w+),?\s?)+[\.!?]$? didefinisikan seperti yang ditunjukkan pada tabel berikut.

Pola	Deskripsi
`\b`	Mulai dari batas kata.
`\(?`	Cocokkan nol atau satu kemunculan tanda kurung buka ("(").
`(?>\w+),?`	Cocokkan satu atau lebih karakter kata, diikuti dengan nol atau satu koma. Jangan mundur saat mencocokkan karakter kata.
`\s?`	Cocokkan nol atau satu karakter spasi kosong.
`((\w+),?\s?)+`	Cocokkan kombinasi satu atau beberapa karakter kata, nol atau satu koma, dan nol atau satu karakter spasi kosong satu kali atau lebih.
`[\.!?]\)?`	Cocokkan salah satu dari tiga simbol tanda baca, diikuti dengan nol atau satu tanda kurung tutup (")").

Anda juga dapat menggunakan elemen sebaris (?n) untuk menekan pengambilan otomatis. Contoh berikut memodifikasi pola regex sebelumnya untuk menggunakan elemen sebaris (?n), alih-alih opsi RegexOptions.ExplicitCapture.

using System;
using System.Text.RegularExpressions;

public class Explicit2Example
{
    public static void Main()
    {
        string input = "This is the first sentence. Is it the beginning " +
                       "of a literary masterpiece? I think not. Instead, " +
                       "it is a nonsensical paragraph.";
        string pattern = @"(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?";

        foreach (Match match in Regex.Matches(input, pattern))
        {
            Console.WriteLine("The match: {0}", match.Value);
            int groupCtr = 0;
            foreach (Group group in match.Groups)
            {
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
                groupCtr++;
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
                    captureCtr++;
                }
            }
        }
    }
}
// The example displays the following output:
//       The match: This is the first sentence.
//          Group 0: This is the first sentence.
//             Capture 0: This is the first sentence.
//       The match: Is it the beginning of a literary masterpiece?
//          Group 0: Is it the beginning of a literary masterpiece?
//             Capture 0: Is it the beginning of a literary masterpiece?
//       The match: I think not.
//          Group 0: I think not.
//             Capture 0: I think not.
//       The match: Instead, it is a nonsensical paragraph.
//          Group 0: Instead, it is a nonsensical paragraph.
//             Capture 0: Instead, it is a nonsensical paragraph.

Imports System.Text.RegularExpressions

Module Explicit2Example
    Public Sub Main()
        Dim input As String = "This is the first sentence. Is it the beginning " +
                              "of a literary masterpiece? I think not. Instead, " +
                              "it is a nonsensical paragraph."
        Dim pattern As String = "(?n)\b\(?((?>\w+),?\s?)+[\.!?]\)?"

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("The match: {0}", match.Value)
            Dim groupCtr As Integer = 0
            For Each group As Group In match.Groups
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
                groupCtr += 1
                Dim captureCtr As Integer = 0
                For Each capture As Capture In group.Captures
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
                    captureCtr += 1
                Next
            Next
        Next
    End Sub
End Module
' The example displays the following output:
'       The match: This is the first sentence.
'          Group 0: This is the first sentence.
'             Capture 0: This is the first sentence.
'       The match: Is it the beginning of a literary masterpiece?
'          Group 0: Is it the beginning of a literary masterpiece?
'             Capture 0: Is it the beginning of a literary masterpiece?
'       The match: I think not.
'          Group 0: I think not.
'             Capture 0: I think not.
'       The match: Instead, it is a nonsensical paragraph.
'          Group 0: Instead, it is a nonsensical paragraph.
'             Capture 0: Instead, it is a nonsensical paragraph.

Terakhir, Anda dapat menggunakan elemen grup sebaris (?n:) untuk menekan pengambilan otomatis berdasarkan grup demi grup. Contoh berikut memodifikasi pola sebelumnya untuk menekan pengambilan tanpa nama di grup luar, ((?>\w+),?\s?). Perhatikan bahwa ini juga menekan pengambilan tanpa nama di grup dalam.

using System;
using System.Text.RegularExpressions;

public class Explicit3Example
{
    public static void Main()
    {
        string input = "This is the first sentence. Is it the beginning " +
                       "of a literary masterpiece? I think not. Instead, " +
                       "it is a nonsensical paragraph.";
        string pattern = @"\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?";

        foreach (Match match in Regex.Matches(input, pattern))
        {
            Console.WriteLine("The match: {0}", match.Value);
            int groupCtr = 0;
            foreach (Group group in match.Groups)
            {
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value);
                groupCtr++;
                int captureCtr = 0;
                foreach (Capture capture in group.Captures)
                {
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value);
                    captureCtr++;
                }
            }
        }
    }
}
// The example displays the following output:
//       The match: This is the first sentence.
//          Group 0: This is the first sentence.
//             Capture 0: This is the first sentence.
//       The match: Is it the beginning of a literary masterpiece?
//          Group 0: Is it the beginning of a literary masterpiece?
//             Capture 0: Is it the beginning of a literary masterpiece?
//       The match: I think not.
//          Group 0: I think not.
//             Capture 0: I think not.
//       The match: Instead, it is a nonsensical paragraph.
//          Group 0: Instead, it is a nonsensical paragraph.
//             Capture 0: Instead, it is a nonsensical paragraph.

Imports System.Text.RegularExpressions

Module Explicit3Example
    Public Sub Main()
        Dim input As String = "This is the first sentence. Is it the beginning " +
                              "of a literary masterpiece? I think not. Instead, " +
                              "it is a nonsensical paragraph."
        Dim pattern As String = "\b\(?(?n:(?>\w+),?\s?)+[\.!?]\)?"

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine("The match: {0}", match.Value)
            Dim groupCtr As Integer = 0
            For Each group As Group In match.Groups
                Console.WriteLine("   Group {0}: {1}", groupCtr, group.Value)
                groupCtr += 1
                Dim captureCtr As Integer = 0
                For Each capture As Capture In group.Captures
                    Console.WriteLine("      Capture {0}: {1}", captureCtr, capture.Value)
                    captureCtr += 1
                Next
            Next
        Next
    End Sub
End Module
' The example displays the following output:
'       The match: This is the first sentence.
'          Group 0: This is the first sentence.
'             Capture 0: This is the first sentence.
'       The match: Is it the beginning of a literary masterpiece?
'          Group 0: Is it the beginning of a literary masterpiece?
'             Capture 0: Is it the beginning of a literary masterpiece?
'       The match: I think not.
'          Group 0: I think not.
'             Capture 0: I think not.
'       The match: Instead, it is a nonsensical paragraph.
'          Group 0: Instead, it is a nonsensical paragraph.
'             Capture 0: Instead, it is a nonsensical paragraph.

Regex yang dikompilasi

Catatan

Jika memungkinkan, gunakan ekspresi reguler yang dihasilkan sumber alih-alih mengkompilasi ekspresi reguler menggunakan RegexOptions.Compiled opsi . Pembuatan sumber dapat membantu aplikasi Anda mulai lebih cepat, berjalan lebih cepat, dan lebih mudah dipangkas. Untuk mempelajari kapan pembuatan sumber dimungkinkan, lihat Kapan menggunakannya.

Secara default, regex di .NET ditafsirkan. Saat objek Regex dibuat atau metode Regex statis dipanggil, pola regex diuraikan menjadi satu set opcode kustom, dan penafsir menggunakan opcode ini untuk menjalankan regex. Ini melibatkan tradeoff: biaya inisialisasi mesin ekspresi reguler diminimalkan dengan mengorbankan performa run-time.

Anda dapat menggunakan regex yang dikompilasi alih-alih yang ditafsirkan menggunakan opsi RegexOptions.Compiled. Dalam hal ini, ketika pola diteruskan ke mesin ekspresi reguler, pola diurai menjadi satu set opcode dan kemudian dikonversi ke bahasa perantara umum (CIL), yang dapat diteruskan langsung ke runtime bahasa umum. Regex yang dikompilasi memaksimalkan performa run-time dengan mengorbankan waktu inisialisasi.

Catatan

Regex dapat dikompilasi hanya dengan memberikan nilai RegexOptions.Compiled ke parameter options dari konstruktor kelas Regex atau metode pencocokan pola statis. Ini tidak tersedia sebagai opsi sebaris.

Anda dapat menggunakan regex yang dikompilasi dalam panggilan ke regex statis dan instans. Dalam regex statis, opsi RegexOptions.Compiled diteruskan ke parameter options dari metode pencocokan pola regex. Dalam ekspresi reguler, ekspresi tersebut diteruskan ke options parameter Regex konstruktor kelas. Dalam kedua kasus ini, regex menghasilkan peningkatan performa.

Namun, peningkatan performa ini hanya terjadi dalam kondisi berikut:

Objek Regex yang mewakili regex tertentu digunakan dalam beberapa panggilan ke metode pencocokan pola regex.
Objek Regex tidak diizinkan keluar dari cakupan, sehingga dapat digunakan kembali.
Regex statis digunakan dalam beberapa panggilan ke metode pencocokan pola regex. (Peningkatan performa dimungkinkan karena regex yang digunakan dalam panggilan metode statis di-cache oleh mesin regex.)

Catatan

Opsi RegexOptions.Compiled ini tidak terkait dengan metode usang Regex.CompileToAssembly , yang membuat rakitan tujuan khusus yang berisi ekspresi reguler yang telah ditentukan sebelumnya dan dikompilasi.

Mengabaikan spasi kosong

Secara default, spasi dalam pola regex sifatnya signifikan; ini memaksa mesin regex untuk mencocokkan karakter spasi kosong dalam string input. Karena itu, regex "\b\w+\s" dan "\b\w+ " adalah regex yang kira-kira setara. Selain itu, ketika tanda angka (#) ditemukan dalam pola regex, ini ditafsirkan sebagai karakter harfiah yang akan dicocokkan.

Opsi RegexOptions.IgnorePatternWhitespace, atau opsi sebaris x, mengubah perilaku default ini sebagai berikut:

Spasi kosong yang tidak di-escape dalam pola regex diabaikan. Untuk menjadi bagian dari pola regex, karakter spasi kosong harus di-escape (misalnya, sebagai \s atau "\ ").
Tanda angka (#) ditafsirkan sebagai awal komentar, bukan sebagai karakter harfiah. Semua teks dalam pola regex dari karakter # ke karakter \n berikutnya atau ke akhir string, ditafsirkan sebagai komentar.

Namun, dalam kasus berikut, karakter spasi kosong dalam regex tidak diabaikan, meskipun Anda menggunakan opsi RegexOptions.IgnorePatternWhitespace:

Spasi kosong dalam kelas karakter selalu ditafsirkan secara harfiah. Misalnya, pola regex [ .,;:] cocok dengan semua karakter spasi tunggal, titik, koma, titik koma, atau titik dua.
Spasi kosong tidak diperbolehkan dalam kuantifier dalam kurung, seperti {n}, {n,}, dan {n,m}. Misalnya, pola regex \d{1, 3} gagal mencocokkan urutan angka apa pun dari satu hingga tiga angka karena berisi karakter spasi kosong.
Spasi kosong tidak diperbolehkan dalam urutan karakter yang memperkenalkan elemen bahasa. Contohnya:
- (?:Subekspresi) elemen bahasa mewakili grup yang tidak mengambil, dan bagian (?: elemen tidak boleh memiliki spasi yang disematkan. (? :Subekspresi) pola menampilkan ArgumentException pada run-time karena mesin regex tidak dapat mengurai pola, dan ( ?:subekspresi) pola gagal mencocokkan subekspresi.
- \p{Nama} elemen bahasa, yang mewakili kategori Unicode atau blok bernama, tidak boleh menyertakan spasi yang disematkan di bagian \p{ elemen. Jika Anda menyertakan spasi kosong, elemen akan menampilkan ArgumentException pada run-time.

Mengaktifkan opsi ini membantu menyederhanakan regex yang sering kali sulit diuraikan dan dipahami. Ini meningkatkan keterbacaan, dan memungkinkan untuk mendokumentasikan regex.

Contoh berikut mendefinisikan pola regex berikut:

\b $? ( (?>\w+) ,?\s? )+ [\.!?] $? # Matches an entire sentence.

Pola ini mirip dengan pola yang ditentukan di bagian Hanya Pengambilan Eksplisit, hanya saja pola ini menggunakan opsi RegexOptions.IgnorePatternWhitespace untuk mengabaikan spasi kosong pola.

using System;
using System.Text.RegularExpressions;

public class Whitespace1Example
{
    public static void Main()
    {
        string input = "This is the first sentence. Is it the beginning " +
                       "of a literary masterpiece? I think not. Instead, " +
                       "it is a nonsensical paragraph.";
        string pattern = @"\b \(? ( (?>\w+) ,?\s? )+ [\.!?] \)? # Matches an entire sentence.";

        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace))
            Console.WriteLine(match.Value);
    }
}
// The example displays the following output:
//       This is the first sentence.
//       Is it the beginning of a literary masterpiece?
//       I think not.
//       Instead, it is a nonsensical paragraph.

Imports System.Text.RegularExpressions

Module Whitespace1Example
    Public Sub Main()
        Dim input As String = "This is the first sentence. Is it the beginning " +
                              "of a literary masterpiece? I think not. Instead, " +
                              "it is a nonsensical paragraph."
        Dim pattern As String = "\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence."

        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnorePatternWhitespace)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       This is the first sentence.
'       Is it the beginning of a literary masterpiece?
'       I think not.
'       Instead, it is a nonsensical paragraph.

Contoh berikut menggunakan opsi sebaris (?x) untuk mengabaikan spasi kosong pola.

using System;
using System.Text.RegularExpressions;

public class Whitespace2Example
{
    public static void Main()
    {
        string input = "This is the first sentence. Is it the beginning " +
                       "of a literary masterpiece? I think not. Instead, " +
                       "it is a nonsensical paragraph.";
        string pattern = @"(?x)\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence.";

        foreach (Match match in Regex.Matches(input, pattern))
            Console.WriteLine(match.Value);
    }
}
// The example displays the following output:
//       This is the first sentence.
//       Is it the beginning of a literary masterpiece?
//       I think not.
//       Instead, it is a nonsensical paragraph.

Imports System.Text.RegularExpressions

Module Whitespace2Example
    Public Sub Main()
        Dim input As String = "This is the first sentence. Is it the beginning " +
                              "of a literary masterpiece? I think not. Instead, " +
                              "it is a nonsensical paragraph."
        Dim pattern As String = "(?x)\b \(? ( (?>\w+) ,?\s? )+  [\.!?] \)? # Matches an entire sentence."

        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       This is the first sentence.
'       Is it the beginning of a literary masterpiece?
'       I think not.
'       Instead, it is a nonsensical paragraph.

Mode kanan-ke-kiri

Secara default, mesin regex mencari dari kiri ke kanan. Anda dapat membalikkan arah pencarian menggunakan opsi RegexOptions.RightToLeft. Pencarian kanan-ke-kiri secara otomatis dimulai pada posisi karakter terakhir dari string. Untuk metode pencocokan pola yang menyertakan parameter posisi awal, seperti Regex.Match(String, Int32), posisi awal yang ditentukan adalah indeks posisi karakter paling kanan tempat pencarian akan dimulai.

Catatan

Mode pola kanan-ke-kiri hanya tersedia dengan menyediakan nilai RegexOptions.RightToLeft ke parameter options dari konstruktor kelas Regex atau metode pencocokan pola statis. Ini tidak tersedia sebagai opsi sebaris.

Contoh

Regex \bb\w+\s mencocokkan kata dengan dua karakter atau lebih yang dimulai dengan huruf "b" dan diikuti oleh karakter spasi kosong. Dalam contoh berikut, string input terdiri dari tiga kata yang menyertakan satu atau beberapa karakter "b". Kata pertama dan kedua dimulai dengan "b" dan kata ketiga diakhiri dengan "b". Seperti yang ditunjukkan oleh output dari contoh pencarian kanan-ke-kiri, hanya kata pertama dan kedua yang cocok dengan pola regex, dengan kata kedua yang dicocokkan terlebih dahulu.

using System;
using System.Text.RegularExpressions;

public class RTL1Example
{
    public static void Main()
    {
        string pattern = @"\bb\w+\s";
        string input = "build band tab";
        foreach (Match match in Regex.Matches(input, pattern, RegexOptions.RightToLeft))
            Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index);
    }
}
// The example displays the following output:
//       'band ' found at position 6.
//       'build ' found at position 0.

Imports System.Text.RegularExpressions

Module RTL1Example
    Public Sub Main()
        Dim pattern As String = "\bb\w+\s"
        Dim input As String = "build band tab"
        For Each match As Match In Regex.Matches(input, pattern, RegexOptions.RightToLeft)
            Console.WriteLine("'{0}' found at position {1}.", match.Value, match.Index)
        Next
    End Sub
End Module
' The example displays the following output:
'       'band ' found at position 6.
'       'build ' found at position 0.

Urutan evaluasi

Opsi RegexOptions.RightToLeft mengubah arah pencarian dan juga membalik urutan evaluasi pola regex. Dalam pencarian kanan-ke-kiri, pola pencarian dibaca dari kanan ke kiri. Perbedaan ini penting karena dapat memengaruhi hal-hal seperti grup pengambilan dan backreferences. Misalnya, ekspresi Regex.Match("abcabc", @"\1(abc)", RegexOptions.RightToLeft) menemukan kecocokan abcabc, tetapi dalam pencarian kiri-ke-kanan (Regex.Match("abcabc", @"\1(abc)", RegexOptions.None)), tidak ada kecocokan yang ditemukan. Itu karena elemen (abc) harus dievaluasi sebelum elemen grup penangkap bernomor (\1) agar kecocokan dapat ditemukan.

Pernyataan lookahead dan lookbehind

Lokasi kecocokan untuk pernyataan lookahead ((?=subexpression)) atau lookbehind ((?<=subexpression)) tidak berubah dalam pencarian kanan-ke-kiri. Pernyataan lookahead mencari ke sebelah kanan dari lokasi kecocokan saat ini; pernyataan lookbehind mencari ke kiri dari lokasi kecocokan saat ini.

Tip

Baik pencarian berupa kanan-ke-kiri atau tidak, lookbehinds diterapkan menggunakan pencarian kanan-ke-kiri yang dimulai dari lokasi kecocokan saat ini.

Misalnya, regex (?<=\d{1,2}\s)\w+,\s\d{4} menggunakan pernyataan lookbehind untuk menguji tanggal yang mendahului nama bulan. Regex kemudian mencocokkan dengan bulan dan tahun. Untuk informasi tentang pernyataan lookahead dan lookbehind, lihat Konstruksi Pengelompokan.

using System;
using System.Text.RegularExpressions;

public class RTL2Example
{
    public static void Main()
    {
        string[] inputs = { "1 May, 1917", "June 16, 2003" };
        string pattern = @"(?<=\d{1,2}\s)\w+,\s\d{4}";

        foreach (string input in inputs)
        {
            Match match = Regex.Match(input, pattern, RegexOptions.RightToLeft);
            if (match.Success)
                Console.WriteLine("The date occurs in {0}.", match.Value);
            else
                Console.WriteLine("{0} does not match.", input);
        }
    }
}

// The example displays the following output:
//       The date occurs in May, 1917.
//       June 16, 2003 does not match.

Imports System.Text.RegularExpressions

Module RTL2Example
    Public Sub Main()
        Dim inputs() As String = {"1 May, 1917", "June 16, 2003"}
        Dim pattern As String = "(?<=\d{1,2}\s)\w+,\s\d{4}"

        For Each input As String In inputs
            Dim match As Match = Regex.Match(input, pattern, RegexOptions.RightToLeft)
            If match.Success Then
                Console.WriteLine("The date occurs in {0}.", match.Value)
            Else
                Console.WriteLine("{0} does not match.", input)
            End If
        Next
    End Sub
End Module

' The example displays the following output:
'       The date occurs in May, 1917.
'       June 16, 2003 does not match.

Pola regex didefinisikan seperti yang ditunjukkan pada tabel berikut.

Pola	Deskripsi
`(?<=\d{1,2}\s)`	Awal kecocokan harus didahului dengan satu atau dua angka desimal yang diikuti dengan spasi.
`\w+`	Mencocokkan satu atau beberapa karakter kata.
`,`	Cocokkan satu karakter koma.
`\s`	Cocokkan karakter spasi kosong.
`\d{4}`	Cocokkan empat angka desimal.

Perilaku pencocokan ECMAScript

Secara default, mesin regex menggunakan perilaku kanonis saat mencocokkan pola regex dengan teks input. Namun, Anda dapat menginstruksikan mesin regex untuk menggunakan perilaku pencocokan ECMAScript dengan menentukan opsi RegexOptions.ECMAScript.

Catatan

Perilaku yang sesuai dengan ECMAScript hanya tersedia dengan memberikan nilai RegexOptions.ECMAScript ke parameter options dari konstruktor kelas Regex atau metode pencocokan pola statis. Ini tidak tersedia sebagai opsi sebaris.

Opsi RegexOptions.ECMAScript hanya dapat digabungkan dengan opsi RegexOptions.IgnoreCase dan RegexOptions.Multiline. Penggunaan opsi lain apa pun dalam regex menghasilkan ArgumentOutOfRangeException.

Perilaku ECMAScript dan regex kanonis berbeda dalam tiga area: sintaks kelas karakter, grup pengambilan referensi mandiri, dan interpretasi oktal versus referensi latar.

Sintaks kelas karakter. Karena regex kanonis mendukung Unicode sementara ECMAScript tidak, kelas karakter dalam ECMAScript memiliki sintaks yang lebih terbatas, dan beberapa elemen bahasa kelas karakter memiliki arti yang berbeda. Misalnya, ECMAScript tidak mendukung elemen bahasa seperti kategori Unicode atau elemen blok \p dan \P. Demikian pula, elemen \w, yang cocok dengan karakter kata, setara dengan kelas karakter [a-zA-Z_0-9] saat menggunakan ECMAScript dan [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}] saat menggunakan perilaku kanonis. Untuk informasi selengkapnya, lihat Kelas Karakter.

Contoh berikut mengilustrasikan perbedaan antara pencocokan pola kanonis dan ECMAScript. Ini mendefinisikan regex, \b(\w+\s*)+, yang mencocokkan dengan kata-kata yang diikuti oleh karakter spasi kosong. Input terdiri dari dua string, satu yang menggunakan tataan karakter Latin dan yang satu lagi yang menggunakan tataan karakter Cyrillic. Seperti yang ditunjukkan output, panggilan ke metode Regex.IsMatch(String, String, RegexOptions) yang menggunakan pencocokan ECMAScript gagal untuk mencocokkan kata-kata Cyrillic, sedangkan panggilan metode yang menggunakan pencocokan kanonis mencocokkan dengan kata-kata ini.

using System;
using System.Text.RegularExpressions;

public class EcmaScriptExample
{
    public static void Main()
    {
        string[] values = { "целый мир", "the whole world" };
        string pattern = @"\b(\w+\s*)+";
        foreach (var value in values)
        {
            Console.Write("Canonical matching: ");
            if (Regex.IsMatch(value, pattern))
                Console.WriteLine("'{0}' matches the pattern.", value);
            else
                Console.WriteLine("{0} does not match the pattern.", value);

            Console.Write("ECMAScript matching: ");
            if (Regex.IsMatch(value, pattern, RegexOptions.ECMAScript))
                Console.WriteLine("'{0}' matches the pattern.", value);
            else
                Console.WriteLine("{0} does not match the pattern.", value);
            Console.WriteLine();
        }
    }
}
// The example displays the following output:
//       Canonical matching: 'целый мир' matches the pattern.
//       ECMAScript matching: целый мир does not match the pattern.
//
//       Canonical matching: 'the whole world' matches the pattern.
//       ECMAScript matching: 'the whole world' matches the pattern.

Imports System.Text.RegularExpressions

Module Ecma1Example
    Public Sub Main()
        Dim values() As String = {"целый мир", "the whole world"}
        Dim pattern As String = "\b(\w+\s*)+"
        For Each value In values
            Console.Write("Canonical matching: ")
            If Regex.IsMatch(value, pattern) Then
                Console.WriteLine("'{0}' matches the pattern.", value)
            Else
                Console.WriteLine("{0} does not match the pattern.", value)
            End If

            Console.Write("ECMAScript matching: ")
            If Regex.IsMatch(value, pattern, RegexOptions.ECMAScript) Then
                Console.WriteLine("'{0}' matches the pattern.", value)
            Else
                Console.WriteLine("{0} does not match the pattern.", value)
            End If
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       Canonical matching: 'целый мир' matches the pattern.
'       ECMAScript matching: целый мир does not match the pattern.
'       
'       Canonical matching: 'the whole world' matches the pattern.
'       ECMAScript matching: 'the whole world' matches the pattern.

Grup pengambilan referensi mandiri. Kelas pengambilan regex dengan referensi latar ke dirinya sendiri harus diperbarui dengan setiap perulangan pengambilan. Seperti yang ditunjukkan contoh berikut, fitur ini memungkinkan regex ((a+)(\1) ?)+ untuk mencocokkan string input " aa aaaa aaaaaa " saat menggunakan ECMAScript, tetapi tidak saat menggunakan pencocokan kanonis.

using System;
using System.Text.RegularExpressions;

public class EcmaScript2Example
{
    static string pattern;

    public static void Main()
    {
        string input = "aa aaaa aaaaaa ";
        pattern = @"((a+)(\1) ?)+";

        // Match input using canonical matching.
        AnalyzeMatch(Regex.Match(input, pattern));

        // Match input using ECMAScript.
        AnalyzeMatch(Regex.Match(input, pattern, RegexOptions.ECMAScript));
    }

    private static void AnalyzeMatch(Match m)
    {
        if (m.Success)
        {
            Console.WriteLine("'{0}' matches {1} at position {2}.",
                              pattern, m.Value, m.Index);
            int grpCtr = 0;
            foreach (Group grp in m.Groups)
            {
                Console.WriteLine("   {0}: '{1}'", grpCtr, grp.Value);
                grpCtr++;
                int capCtr = 0;
                foreach (Capture cap in grp.Captures)
                {
                    Console.WriteLine("      {0}: '{1}'", capCtr, cap.Value);
                    capCtr++;
                }
            }
        }
        else
        {
            Console.WriteLine("No match found.");
        }
        Console.WriteLine();
    }
}
// The example displays the following output:
//    No match found.
//
//    '((a+)(\1) ?)+' matches aa aaaa aaaaaa  at position 0.
//       0: 'aa aaaa aaaaaa '
//          0: 'aa aaaa aaaaaa '
//       1: 'aaaaaa '
//          0: 'aa '
//          1: 'aaaa '
//          2: 'aaaaaa '
//       2: 'aa'
//          0: 'aa'
//          1: 'aa'
//          2: 'aa'
//       3: 'aaaa '
//          0: ''
//          1: 'aa '
//          2: 'aaaa '

Imports System.Text.RegularExpressions

Module Ecma2Example
    Dim pattern As String

    Public Sub Main()
        Dim input As String = "aa aaaa aaaaaa "
        pattern = "((a+)(\1) ?)+"

        ' Match input using canonical matching.
        AnalyzeMatch(Regex.Match(input, pattern))

        ' Match input using ECMAScript.
        AnalyzeMatch(Regex.Match(input, pattern, RegexOptions.ECMAScript))
    End Sub

    Private Sub AnalyzeMatch(m As Match)
        If m.Success Then
            Console.WriteLine("'{0}' matches {1} at position {2}.",
                              pattern, m.Value, m.Index)
            Dim grpCtr As Integer = 0
            For Each grp As Group In m.Groups
                Console.WriteLine("   {0}: '{1}'", grpCtr, grp.Value)
                grpCtr += 1
                Dim capCtr As Integer = 0
                For Each cap As Capture In grp.Captures
                    Console.WriteLine("      {0}: '{1}'", capCtr, cap.Value)
                    capCtr += 1
                Next
            Next
        Else
            Console.WriteLine("No match found.")
        End If
        Console.WriteLine()
    End Sub
End Module
' The example displays the following output:
'    No match found.
'    
'    '((a+)(\1) ?)+' matches aa aaaa aaaaaa  at position 0.
'       0: 'aa aaaa aaaaaa '
'          0: 'aa aaaa aaaaaa '
'       1: 'aaaaaa '
'          0: 'aa '
'          1: 'aaaa '
'          2: 'aaaaaa '
'       2: 'aa'
'          0: 'aa'
'          1: 'aa'
'          2: 'aa'
'       3: 'aaaa '
'          0: ''
'          1: 'aa '
'          2: 'aaaa '

Regex didefinisikan seperti yang ditunjukkan pada tabel berikut.

Pola	Deskripsi
(a+)	Cocokkan huruf "a" satu atau beberapa kali. Ini adalah grup pengambilan kedua.
(\1)	Cocokkan substring yang diambil oleh grup pengambilan pertama. Ini adalah grup pengambilan ketiga.
?	Cocokkan nol atau satu karakter spasi.
((a+)(\1) ?)+	Cocokkan pola satu atau lebih karakter "a", diikuti dengan string yang cocok dengan grup pengambilan pertama, diikuti dengan nol atau satu karakter spasi satu atau beberapa kali. Ini adalah grup penangkapan pertama.

Resolusi ambiguitas antara lolos oktal dan referensi latar. Tabel berikut merangkum perbedaan interpretasi oktal versus referensi latar oleh regex kanonis dan ECMAScript.

Ekspresi reguler	Perilaku kanonis	Perilaku ECMAScript
`\0` diikuti oleh 0 hingga 2 angka oktal	Tafsirkan sebagai oktal. Misalnya, `\044` selalu ditafsirkan sebagai nilai oktal dan berarti "$".	Perilaku yang sama.
`\` diikuti dengan angka dari 1 sampai 9, diikuti dengan tidak adanya tambahan angka desimal,	Tafsirkan sebagai referensi latar. Misalnya, `\9` selalu berarti referensi latar 9, meskipun grup pengambilan kesembilan tidak ada. Jika grup pengambilan tidak ada, pengurai regex menampilkan ArgumentException.	Jika ada grup pengambilan satu angka desimal, lakukan referensi latar ke angka tersebut. Jika tidak, tafsirkan nilai sebagai harfiah.
`\` diikuti oleh angka dari 1 hingga 9, diikuti oleh angka desimal tambahan	Tafsirkan angka sebagai nilai desimal. Jika grup pengambilan tersebut ada, tafsirkan ekspresi sebagai referensi latar. Jika tidak, tafsirkan angka oktal awal hingga oktal 377; artinya, pertimbangkan hanya 8 bit rendah dari nilai. Tafsirkan angka yang tersisa sebagai harfiah. Misalnya, dalam ekspresi `\3000`, jika ada grup pengambilan 300, tafsirkan sebagai referensi latar 300; jika grup pengambilan 300 tidak ada, tafsirkan sebagai oktal 300 diikuti oleh 0.	Tafsirkan sebagai referensi latar dengan mengonversi angka sebanyak mungkin ke nilai desimal yang dapat merujuk ke pengambilan. Jika tidak ada angka yang dapat dikonversi, tafsirkan sebagai oktal menggunakan angka oktal awal hingga oktal 377; tafsirkan angka yang tersisa sebagai harfiah.

Membandingkan dengan menggunakan kultur invarian

Secara default, ketika mesin regex melakukan perbandingan yang tidak peka huruf besar/kecil, mesin ini menggunakan konvensi casing dari kultur saat ini untuk menentukan karakter huruf besar dan kecil yang setara.

Namun, perilaku ini tidak diinginkan untuk beberapa jenis perbandingan, terutama saat membandingkan input pengguna dengan nama sumber daya sistem, seperti kata sandi, file, atau URL. Contoh berikut mengilustrasikan skenario seperti itu. Kode dimaksudkan untuk memblokir akses ke sumber daya apa pun yang URL-nya diawali dengan FILE://. Regex mencoba pencocokan peka huruf besar/kecil dengan string menggunakan regex $FILE://. Namun, ketika budaya sistem saat ini adalah tr-TR (Turkish-Türkiye), "I" bukan huruf besar yang setara dengan "i". Akibatnya, panggilan ke metode Regex.IsMatch mengembalikan false, dan akses ke file diizinkan.

CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");

string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";

Console.WriteLine("Culture-sensitive matching ({0} culture)...",
                  Thread.CurrentThread.CurrentCulture.Name);
if (Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase))
    Console.WriteLine("URLs that access files are not allowed.");
else
    Console.WriteLine("Access to {0} is allowed.", input);

Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
//       Culture-sensitive matching (tr-TR culture)...
//       Access to file://c:/Documents.MyReport.doc is allowed.

Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")

Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"

Console.WriteLine("Culture-sensitive matching ({0} culture)...",
                  Thread.CurrentThread.CurrentCulture.Name)
If Regex.IsMatch(input, pattern, RegexOptions.IgnoreCase) Then
    Console.WriteLine("URLs that access files are not allowed.")
Else
    Console.WriteLine("Access to {0} is allowed.", input)
End If

Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
'       Culture-sensitive matching (tr-TR culture)...
'       Access to file://c:/Documents.MyReport.doc is allowed.

Catatan

Untuk informasi selengkapnya tentang perbandingan string yang peka huruf besar/kecil dan yang menggunakan kultur invarian, lihat Praktik Terbaik untuk Menggunakan String.

Alih-alih menggunakan perbandingan yang tidak peka huruf besar/kecil dari kultur saat ini, Anda dapat menentukan opsi RegexOptions.CultureInvariant untuk mengabaikan perbedaan kultur dalam bahasa dan menggunakan konvensi kultur invarian.

Catatan

Perbandingan menggunakan kultur invarian hanya tersedia dengan menyediakan nilai RegexOptions.CultureInvariant ke parameter options dari konstruktor kelas Regex atau metode pencocokan pola statis. Ini tidak tersedia sebagai opsi sebaris.

Contoh berikut mirip dengan contoh sebelumnya, hanya saja metode Regex.IsMatch(String, String, RegexOptions) statis dipanggil dengan opsi yang menyertakan RegexOptions.CultureInvariant. Bahkan ketika budaya saat ini diatur ke Turki (Türkiye), mesin ekspresi reguler dapat berhasil mencocokkan "FILE" dan "file" dan memblokir akses ke sumber daya file.

CultureInfo defaultCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR");

string input = "file://c:/Documents.MyReport.doc";
string pattern = "FILE://";

Console.WriteLine("Culture-insensitive matching...");
if (Regex.IsMatch(input, pattern,
                  RegexOptions.IgnoreCase | RegexOptions.CultureInvariant))
    Console.WriteLine("URLs that access files are not allowed.");
else
    Console.WriteLine("Access to {0} is allowed.", input);

Thread.CurrentThread.CurrentCulture = defaultCulture;
// The example displays the following output:
//       Culture-insensitive matching...
//       URLs that access files are not allowed.

Dim defaultCulture As CultureInfo = Thread.CurrentThread.CurrentCulture
Thread.CurrentThread.CurrentCulture = New CultureInfo("tr-TR")

Dim input As String = "file://c:/Documents.MyReport.doc"
Dim pattern As String = "$FILE://"

Console.WriteLine("Culture-insensitive matching...")
If Regex.IsMatch(input, pattern,
               RegexOptions.IgnoreCase Or RegexOptions.CultureInvariant) Then
    Console.WriteLine("URLs that access files are not allowed.")
Else
    Console.WriteLine("Access to {0} is allowed.", input)
End If
Thread.CurrentThread.CurrentCulture = defaultCulture
' The example displays the following output:
'        Culture-insensitive matching...
'        URLs that access files are not allowed.

Mode non-tracking

Secara default, . Mesin regex NET menggunakan backtracking untuk mencoba menemukan kecocokan pola. Mesin backtracking adalah mesin yang mencoba mencocokkan satu pola, dan jika itu gagal, mundur dan mencoba mencocokkan pola alternatif, dan sebagainya. Mesin backtracking sangat cepat untuk kasus-kasus umum, tetapi melambat saat jumlah pergantian pola meningkat, yang dapat menyebabkan bencana backtracking. Opsi RegexOptions.NonBacktracking , yang diperkenalkan di .NET 7, tidak menggunakan backtracking dan menghindari skenario terburuk tersebut. Tujuannya adalah untuk memberikan perilaku yang baik secara konsisten, terlepas dari input yang dicari.

Opsi RegexOptions.NonBacktracking ini tidak mendukung semua dukungan mesin bawaan lainnya. Secara khusus, opsi tidak dapat digunakan bersama dengan RegexOptions.RightToLeft atau RegexOptions.ECMAScript. Ini juga tidak memungkinkan konstruksi berikut dalam pola:

Kelompok atom
Backreferensi
Grup penyeimbangan
Kondisional
Pencarian
Mulai jangkar (\G)

RegexOptions.NonBacktracking juga memiliki perbedaan yang halus sehubungan dengan eksekusi. Jika grup penangkapan berada dalam perulangan, sebagian besar (non-.NET) mesin regex hanya memberikan nilai terakhir yang cocok untuk tangkapan tersebut. Namun. Mesin regex NET melacak semua nilai yang ditangkap di dalam perulangan dan menyediakan akses ke mereka. Opsi RegexOptions.NonBacktracking ini seperti kebanyakan implementasi regex lainnya dan hanya mendukung penyediaan pengambilan akhir.

Untuk informasi selengkapnya tentang backtracking, lihat Backtracking dalam ekspresi reguler.

Lihat juga

Bahasa Regex - Referensi Cepat

Bagikan melalui

Opsi regex

Menentukan opsi

Menentukan opsi

Opsi default

Pencocokan yang peka huruf besar/kecil

Mode multibaris

Mode baris tunggal

Hanya pengambilan eksplisit

Regex yang dikompilasi

Mengabaikan spasi kosong

Mode kanan-ke-kiri

Contoh

Urutan evaluasi

Pernyataan lookahead dan lookbehind

Perilaku pencocokan ECMAScript

Membandingkan dengan menggunakan kultur invarian

Mode non-tracking

Lihat juga

Sumber Daya Tambahan: