Konstruksi Lain-lain dalam Ekspresi Reguler

Ekspresi reguler di .NET mencakup tiga konstruksi bahasa lain-lain. Satu memungkinkan Anda mengaktifkan atau menonaktifkan opsi pencocokan tertentu di tengah pola ekspresi reguler. Dua sisanya memungkinkan Anda menyertakan komentar dalam ekspresi reguler.

Opsi Sebaris

Anda dapat mengatur atau menonaktifkan opsi pencocokan pola tertentu untuk bagian ekspresi reguler dengan menggunakan sintaks

(?imnsx-imnsx)

Anda mencantumkan opsi yang ingin Anda aktifkan setelah tanda tanya, dan opsi yang ingin Anda nonaktifkan setelah tanda minus. Tabel berikut menjelaskan masing-masing elemen. Untuk informasi selengkapnya, lihat Opsi Ekspresi Reguler.

Opsi	Deskripsi
i	Pencocokan yang Tidak Peka Huruf Besar/Kecil.
m	Mode Multibaris.
n	Hanya Pengambilan Eksplisit. (Tanda kurung tidak berfungsi sebagai grup pengambilan.)
s	Mode Satu Baris.
x	Abaikan ruang putih yang tidak lolos, dan izinkan komentar x-mode.

Setiap perubahan opsi ekspresi reguler yang ditentukan oleh (?imnsx-imnsx) konstruksi tetap berlaku hingga akhir grup penutup.

Catatan

Konstruksi pengelompokan (?imnsx-imnsx:subekspresi) menyediakan fungsionalitas yang identik untuk subekspresi. Untuk informasi selengkapnya, lihat Konstruksi Pengelompokan.

Contoh berikut menggunakan opsi i, n, dan x untuk mengaktifkan ketidakpekaan terhadap huruf besar/kecil dan pengambilan eksplisit, dan untuk mengabaikan spasi putih dalam pola ekspresi reguler di tengah ekspresi reguler.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern;
      string input = "double dare double Double a Drooling dog The Dreaded Deep";

      pattern = @"\b(D\w+)\s(d\w+)\b";
      // Match pattern using default options.
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            for (int ctr = 1; ctr < match.Groups.Count; ctr++)
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
      }
      Console.WriteLine();

      // Change regular expression pattern to include options.
      pattern = @"\b(D\w+)(?ixn) \s (d\w+) \b";
      // Match new pattern with options.
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
            for (int ctr = 1; ctr < match.Groups.Count; ctr++)
               Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups[ctr].Value);
      }
   }
}
// The example displays the following output:
//       Drooling dog
//          Group 1: Drooling
//          Group 2: dog
//
//       Drooling dog
//          Group 1: 'Drooling'
//       Dreaded Deep
//          Group 1: 'Dreaded'

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String
        Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"

        pattern = "\b(D\w+)\s(d\w+)\b"
        ' Match pattern using default options.
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
            If match.Groups.Count > 1 Then
                For ctr As Integer = 1 To match.Groups.Count - 1
                    Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
                Next
            End If
        Next
        Console.WriteLine()

        ' Change regular expression pattern to include options.
        pattern = "\b(D\w+)(?ixn) \s (d\w+) \b"
        ' Match new pattern with options. 
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
            If match.Groups.Count > 1 Then
                For ctr As Integer = 1 To match.Groups.Count - 1
                    Console.WriteLine("   Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
                Next
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       Drooling dog
'          Group 1: Drooling
'          Group 2: dog
'       
'       Drooling dog
'          Group 1: 'Drooling'
'       Dreaded Deep
'          Group 1: 'Dreaded'

Contoh ini menentukan dua ekspresi reguler. Yang pertama, \b(D\w+)\s(d\w+)\b, cocok dengan dua kata berturut-turut yang dimulai dengan huruf besar "D" dan huruf kecil "d". Ekspresi reguler kedua, \b(D\w+)(?ixn) \s (d\w+) \b, menggunakan opsi sebaris untuk mengubah pola ini, seperti yang dijelaskan dalam tabel berikut. Perbandingan hasil mengonfirmasi efek (?ixn) konstruksi.

Pola	Deskripsi
\b	Mulailah dari batas kata.
(D\w+)	Cocokkan huruf besar "D" diikuti oleh satu atau beberapa karakter kata. Ini adalah grup pengambilan pertama.
(?ixn)	Mulai saat ini, buat perbandingan ketidakpekaan terhadap huruf besar/kecil, buat pengambilan eksplisit saja, dan abaikan ruang putih dalam pola ekspresi reguler.
\s	Cocokkan karakter spasi kosong.
(d\w+)	Cocokkan huruf besar atau kecil "d" diikuti oleh satu atau beberapa karakter kata. Grup ini tidak diambil karena n opsi (pengambilan eksplisit) diaktifkan.
\b	Cocokkan batas kata.

Komentar satu baris

Konstruksi (?#komentar) memungkinkan Anda menyertakan komentar sebaris dalam ekspresi reguler. Mesin ekspresi reguler tidak menggunakan bagian mana pun dari komentar dalam pencocokan pola, meskipun komentar disertakan dalam string yang dikembalikan oleh Regex.ToString metode. Komentar berakhir pada kurung penutup pertama.

Contoh berikut mengulangi pola ekspresi reguler pertama dari contoh di bagian sebelumnya. Ini menambahkan dua komentar sebaris ke ekspresi reguler untuk menunjukkan apakah perbandingannya peka huruf besar/kecil. Pola ekspresi reguler, \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b, didefinisikan sebagai berikut.

Pola	Deskripsi
\b	Mulailah dari batas kata.
(?# case-sensitive comparison)	Sebuah komentar. Itu tidak memengaruhi perilaku pencocokan pola.
(D\w+)	Cocokkan huruf besar "D" diikuti oleh satu atau beberapa karakter kata. Ini adalah grup penangkapan pertama.
\s	Cocokkan karakter spasi kosong.
(?ixn)	Mulai saat ini, buat perbandingan ketidakpekaan terhadap huruf besar/kecil, buat pengambilan eksplisit saja, dan abaikan ruang putih dalam pola ekspresi reguler.
(?#case-insensitive comparison)	Sebuah komentar. Itu tidak memengaruhi perilaku pencocokan pola.
(d\w+)	Cocokkan huruf besar atau kecil "d" diikuti oleh satu atau beberapa karakter kata. Ini adalah grup pengambilan kedua.
\b	Cocokkan batas kata.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b";
      Regex rgx = new Regex(pattern);
      string input = "double dare double Double a Drooling dog The Dreaded Deep";

      Console.WriteLine("Pattern: " + pattern.ToString());
      // Match pattern using default options.
      foreach (Match match in rgx.Matches(input))
      {
         Console.WriteLine(match.Value);
         if (match.Groups.Count > 1)
         {
            for (int ctr = 1; ctr <match.Groups.Count; ctr++)
               Console.WriteLine("   Group {0}: {1}", ctr, match.Groups[ctr].Value);
         }
      }
   }
}
// The example displays the following output:
//    Pattern: \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comp
//    arison)d\w+)\b
//    Drooling dog
//       Group 1: Drooling
//    Dreaded Deep
//       Group 1: Dreaded

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comparison)d\w+)\b"
        Dim rgx As New Regex(pattern)
        Dim input As String = "double dare double Double a Drooling dog The Dreaded Deep"

        Console.WriteLine("Pattern: " + pattern.ToString())
        ' Match pattern using default options.
        For Each match As Match In rgx.Matches(input)
            Console.WriteLine(match.Value)
            If match.Groups.Count > 1 Then
                For ctr As Integer = 1 To match.Groups.Count - 1
                    Console.WriteLine("   Group {0}: {1}", ctr, match.Groups(ctr).Value)
                Next
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'    Pattern: \b((?# case-sensitive comparison)D\w+)\s(?ixn)((?#case-insensitive comp
'    arison)d\w+)\b
'    Drooling dog
'       Group 1: Drooling
'    Dreaded Deep
'       Group 1: Dreaded

Komentar Akhir Baris

Tanda angka (#) menandai komentar mode x, yang dimulai pada karakter # yang tidak diescaped di akhir pola ekspresi reguler dan berlanjut hingga akhir baris. Untuk menggunakan konstruksi ini, Anda harus mengaktifkan x opsi (melalui opsi sebaris) atau memberikan RegexOptions.IgnorePatternWhitespace nilai ke option parameter saat membuat Regex instans objek atau memanggil metode statis Regex.

Contoh berikut mengilustrasikan konstruksi komentar akhir baris. Ini menentukan apakah string adalah string format komposit yang mencakup sedikitnya satu item format. Tabel berikut menjelaskan konstruk dalam pola ekspresi reguler:

\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.

Pola	Deskripsi
\{	Cocokkan kurung kurawal pembuka.
\d+	Cocokkan satu atau beberapa angka desimal.
(,-*\d+)*	Cocokkan nol atau satu kejadian koma, diikuti dengan tanda minus opsional, diikuti oleh satu atau lebih digit desimal.
(\:\w{1,4}?)*	Cocokkan nol atau satu kejadian titik dua, diikuti oleh satu hingga empat, tetapi sesedikit mungkin, karakter ruang putih.
\}	Cocokkan kurung kurawal penutup.
(?x)	Aktifkan opsi abaikan pola spasi putih sehingga komentar akhir baris akan dikenali.
# Looks for a composite format item.	Komentar akhir baris.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item.";
      string input = "{0,-3:F}";
      Console.WriteLine("'{0}':", input);
      if (Regex.IsMatch(input, pattern))
         Console.WriteLine("   contains a composite format item.");
      else
         Console.WriteLine("   does not contain a composite format item.");
   }
}
// The example displays the following output:
//       '{0,-3:F}':
//          contains a composite format item.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\{\d+(,-*\d+)*(\:\w{1,4}?)*\}(?x) # Looks for a composite format item."
        Dim input As String = "{0,-3:F}"
        Console.WriteLine("'{0}':", input)
        If Regex.IsMatch(input, pattern) Then
            Console.WriteLine("   contains a composite format item.")
        Else
            Console.WriteLine("   does not contain a composite format item.")
        End If
    End Sub
End Module
' The example displays the following output:
'       '{0,-3:F}':
'          contains a composite format item.

Perhatikan bahwa, alih-alih memberikan (?x) konstruksi dalam ekspresi reguler, komentar juga dapat dikenali dengan memanggil Regex.IsMatch(String, String, RegexOptions) metode dan meneruskannya nilai RegexOptions.IgnorePatternWhitespace enumerasi.

Lihat juga

• Bahasa Regex - Referensi Cepat