RegexOptions Enum

Definisi

Ruang nama:

System.Text.RegularExpressions

Rakitan:

System.Text.RegularExpressions.dll

Menyediakan nilai enumerasi yang akan digunakan untuk mengatur opsi ekspresi reguler.

Enumerasi ini mendukung kombinasi bitwise dari nilai yang termasuk di dalamnya.

public enum class RegexOptions

[System.Flags]
public enum RegexOptions

[<System.Flags>]
type RegexOptions = 

Public Enum RegexOptions

Warisan

Object

ValueType

Enum

RegexOptions

Atribut

FlagsAttribute

Bidang

Compiled	8	Menentukan bahwa ekspresi reguler dikompilasi ke kode MSIL, alih-alih ditafsirkan. Regex yang dikompilasi memaksimalkan performa run-time dengan mengorbankan waktu inisialisasi. Nilai ini tidak boleh ditetapkan ke Options properti saat memanggil CompileToAssembly(RegexCompilationInfo[], AssemblyName) metode . Untuk informasi selengkapnya, lihat bagian "Ekspresi Reguler Yang Dikompilasi" di artikel Opsi Ekspresi Reguler .
CultureInvariant	512	Menentukan bahwa perbedaan budaya dalam bahasa diabaikan. Untuk informasi selengkapnya, lihat bagian "Perbandingan Menggunakan Budaya Invariant" di artikel Opsi Ekspresi Reguler .
ECMAScript	256	Mengaktifkan perilaku yang mematuhi ECMAScript untuk ekspresi. Nilai ini hanya dapat digunakan bersama dengan IgnoreCasenilai , , Multilinedan Compiled . Penggunaan nilai ini dengan nilai lain menghasilkan pengecualian. Untuk informasi selengkapnya tentang ECMAScript opsi, lihat bagian "Perilaku Pencocokan ECMAScript" di artikel Opsi Ekspresi Reguler .
ExplicitCapture	4	Menentukan bahwa satu-satunya tangkapan yang valid secara eksplisit bernama atau bernomor grup formulir (?<nama>...). Ini memungkinkan tanda kurung yang tidak disebutkan namanya bertindak sebagai grup yang tidak menangkap tanpa kekurangan sintaksis ekspresi (?:...). Untuk informasi selengkapnya, lihat bagian "Hanya Tangkapan Eksplisit" di artikel Opsi Ekspresi Reguler .
IgnoreCase	1	Menentukan pencocokan yang tidak peka huruf besar/kecil. Untuk informasi selengkapnya, lihat bagian "Pencocokan Tidak Peka Huruf Besar/Kecil" di artikel Opsi Ekspresi Reguler .
IgnorePatternWhitespace	32	Menghilangkan spasi kosong yang tidak dilewati dari pola dan mengaktifkan komentar yang ditandai dengan #. Namun, nilai ini tidak memengaruhi atau menghilangkan spasi kosong di kelas karakter, kuantifier numerik, atau token yang menandai awal elemen bahasa ekspresi reguler individu. Untuk informasi selengkapnya, lihat bagian "Abaikan Spasi Putih" dari artikel Opsi Ekspresi Reguler .
Multiline	2	Mode Multibaris. Mengubah arti ^ dan $ sehingga cocok di awal dan akhir, masing-masing, dari baris apa pun, dan bukan hanya awal dan akhir dari seluruh string. Untuk informasi selengkapnya, lihat bagian "Mode Multibaris" di artikel Opsi Ekspresi Reguler .
NonBacktracking	1024	Aktifkan pencocokan menggunakan pendekatan yang menghindari backtracking dan menjamin pemrosesan linear-time dalam panjang input.
None	0	Menentukan bahwa tidak ada opsi yang diatur. Untuk informasi selengkapnya tentang perilaku default mesin ekspresi reguler, lihat bagian "Opsi Default" di artikel Opsi Ekspresi Reguler .
RightToLeft	64	Menentukan bahwa pencarian akan dari kanan ke kiri, bukan dari kiri ke kanan. Untuk informasi selengkapnya, lihat bagian "Mode Kanan-ke-Kiri" di artikel Opsi Ekspresi Reguler .
Singleline	16	Menentukan mode baris tunggal. Mengubah arti titik (.) sehingga cocok dengan setiap karakter (bukan setiap karakter kecuali \n). Untuk informasi selengkapnya, lihat bagian "Mode Baris Tunggal" di artikel Opsi Ekspresi Reguler .

Contoh

Contoh berikut mendefinisikan dua ekspresi reguler yang mengidentifikasi kata-kata berulang dalam teks tetapi dibuat menggunakan nilai yang berbeda RegexOptions . Ekspresi reguler pertama tidak peka huruf besar/kecil; kasus diabaikan saat menentukan apakah kata identik dengan kata sebelumnya. Ekspresi reguler kedua peka huruf besar/kecil; kata harus cocok dengan kasus kata sebelumnya persis untuk dianggap sebagai duplikat.

using System;
using System.Text.RegularExpressions;

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

        // Define a test string.        
        string text = "The the quick brown fox  fox jumps over the lazy dog dog.";
        
        // Find matches using case-insensitive regular expression.
        MatchCollection matches = rxInsensitive.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);
        }
        Console.WriteLine();
        
        // Find matches using case-sensitive regular expression.
        matches = rxSensitive.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 50 and 54
//       
//       2 matches found in:
//          The the quick brown fox  fox jumps over the lazy dog dog.
//       'fox' repeated at positions 20 and 25
//       'dog' repeated at positions 50 and 54

Imports System.Text.RegularExpressions

Public Module Test

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

        ' Define a test string.        
        Dim text As String = "The the quick brown fox  fox jumps over the lazy dog dog."
        
        ' Find matches using case-insensitive regular expression.
        Dim matches As MatchCollection = rxInsensitive.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
        Console.WriteLine()
        
        ' Find matches using case-sensitive regular expression.
        matches = rxSensitive.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
        Console.WriteLine()
    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 50 and 54
'       
'       2 matches found in:
'          The the quick brown fox  fox jumps over the lazy dog dog.
'       'fox' repeated at positions 20 and 25
'       'dog' repeated at positions 50 and 54

Keterangan

Nilai RegexOptions dapat diberikan sebagai parameter untuk anggota Regex kelas berikut:

• Konstruktor Regex.Regex(String, RegexOptions) kelas.

• Metode Regex.Split(String, String, RegexOptions).

• Metode Regex.IsMatch(String, String, RegexOptions).

• Metode Regex.Match(String, String, RegexOptions).

• Metode Regex.Matches(String, String, RegexOptions).

• Metode Regex.Replace(String, String, String, RegexOptions) dan Regex.Replace(String, String, MatchEvaluator, RegexOptions).

Nilai RegexOptions juga dapat disediakan sebagai parameter untuk RegexCompilationInfo konstruktor, atau dapat ditetapkan langsung ke RegexCompilationInfo.Options properti . Objek yang RegexCompilationInfo dihasilkan kemudian digunakan dalam panggilan ke Regex.CompileToAssembly metode .

Beberapa opsi yang disediakan oleh anggota RegexOptions enumerasi (khususnya, oleh , , IgnoreCaseMultiline, dan Singleline anggotanyaExplicitCapture) dapat disediakan dengan menggunakan karakter opsi sebaris dalam pola ekspresi reguler. Untuk detailnya, lihat Opsi Ekspresi Reguler.

Lihat juga

• Options
• Opsi Regex