Bagikan melalui

Kelas karakter di dalam ekspresi reguler

  • Artikel

Kelas karakter mendefinisikan sekumpulan karakter, salah satunya dapat terjadi pada string input agar kecocokan berhasil. Bahasa ekspresi reguler di .NET mendukung kelas karakter berikut ini:

  • Grup karakter positif. Karakter di dalam string input harus cocok dengan salah satu dari sekumpulan karakter yang ditentukan. Untuk informasi selengkapnya, simak Grup Karakter Positif.

  • Kelompok karakter negatif. Karakter di dalam string input tidak boleh cocok dengan salah satu dari sekumpulan karakter yang ditentukan. Untuk informasi selengkapnya, simak Grup Karakter Positif.

  • Karakter apapun. Karakter . (dot atau period) dalam ekspresi reguler adalah karakter wildcard yang cocok dengan karakter apa pun kecuali \n. Untuk informasi lebih lanjut, lihat Karakter Apa Pun.

  • Kategori Unicode umum atau blok bernama. Karakter di dalam string input harus merupakan anggota kategori Unicode tertentu atau harus termasuk dalam rentang karakter Unicode yang berdekatan agar kecocokan berhasil. Untuk informasi selengkapnya, lihat Kategori Unicode atau Blok Unicode.

  • Kategori Unicode umum negatif atau blok bernama. Karakter dalam string input tidak boleh termasuk dalam anggota kategori Unicode tertentu atau rentang karakter Unicode yang berdekatan agar kecocokan berhasil. Untuk informasi selengkapnya, lihat Kategori Unicode atau Blok Unicode.

  • Sebuah karakter kata. Karakter dalam string input dapat termasuk dalam kategori Unicode apa pun yang sesuai untuk karakter dalam kata-kata. Untuk informasi selengkapnya, lihat Karakter Kata.

  • Karakter nonkata. Karakter dalam string input dapat termasuk dalam kategori Unicode apa pun yang bukan karakter kata. Untuk informasi selengkapnya, lihat Karakter Nonkata.

  • Karakter spasi kosong. Karakter dalam string input bisa berupa karakter pemisah Unicode, serta salah satu dari sejumlah karakter kontrol. Untuk informasi lebih lanjut, lihat Karakter Spasi Kosong.

  • Karakter nonspasi kosong. Karakter di dalam string input dapat berupa karakter apa pun yang bukan karakter spasi kosong. Untuk informasi lebih lanjut, lihat Karakter Nonspasi Kosong.

  • Digit desimal. Karakter di dalam string input dapat berupa salah satu dari sejumlah karakter yang diklasifikasikan sebagai digit desimal Unicode. Untuk informasi selengkapnya, lihat Karakter Digit Desimal.

  • Digit nondesimal. Karakter di dalam string input dapat berupa apa pun selain digit desimal Unicode. Untuk informasi selengkapnya, lihat Karakter Digit Desimal.

.NET mendukung ekspresi pengurangan kelas karakter, yang memungkinkan Anda untuk menentukan satu set karakter sebagai hasil dari pengecualian satu kelas karakter dari kelas karakter lain. Untuk informasi lebih lanjut, lihat Pengurangan Kelas Karakter.

Catatan

Kelas karakter yang cocok dengan karakter menurut kategori, seperti \w untuk mencocokkan karakter kata atau \p{} agar sesuai dengan kategori Unicode, mengandalkan kelas CharUnicodeInfo untuk memberikan informasi tentang kategori karakter. Pada .NET Framework 4.6.2 dan versi yang lebih baru, kategori karakter didasarkan pada The Unicode Standard, Versi 8.0.0.

Kelompok karakter positif: [ ]

Grup karakter positif menentukan daftar karakter, salah satunya mungkin muncul pada string input agar kecocokan terjadi. Daftar karakter ini bisa ditentukan secara individual, sebagai rentang, atau keduanya.

Sintaks untuk menentukan daftar karakter individual adalah sebagai berikut:

[*character_group*]

di mana character_group adalah daftar karakter individual yang dapat muncul pada string input agar kecocokan berhasil. character_group bisa terdiri dari kombinasi satu atau beberapa karakter harfiah, karakter escape, atau kelas karakter.

Sintaks untuk menentukan rentang karakter adalah sebagai berikut:

[firstCharacter-lastCharacter]

di mana firstCharacter adalah karakter yang memulai rentang dan lastCharacter adalah karakter yang mengakhiri rentang tersebut. Rentang karakter adalah serangkaian karakter berdekatan yang didefinisikan dengan menentukan karakter pertama dalam seri, tanda hubung (-), dan karakter terakhir dalam seri. Dua karakter disebut bersebelahan jika mereka memiliki titik kode Unicode yang berdekatan. firstCharacter harus berupa karakter dengan titik kode yang lebih rendah, dan lastCharacter harus berupa karakter dengan titik kode yang lebih tinggi.

Catatan

Karena grup karakter positif bisa mencakup sekumpulan karakter dan rentang karakter, karakter tanda hubung (-) selalu ditafsirkan sebagai pemisah rentang kecuali itu adalah karakter pertama atau terakhir dari grup.

Untuk menyertakan tanda hubung sebagai anggota nonperipheral dari grup karakter, keluar darinya. Misalnya, untuk membuat grup karakter untuk karakter a dan karakter dari - ke /, sintaks yang benar adalah [a\--/].

Beberapa pola ekspresi reguler umum yang berisi kelas karakter positif tercantum dalam tabel berikut ini.

Pola Deskripsi
[aeiou] Cocokkan semua huruf hidup.
[\p{P}\d] Cocokkan semua tanda baca dan karakter digit desimal.
[\s\p{P}] Cocokkan semua spasi kosong dan tanda baca.

Contoh berikut ini mendefinisikan grup karakter positif yang berisi karakter "a" dan "e" sehingga string input harus berisi kata "grey" atau "gray" diikuti dengan kata lain agar kecocokan terjadi.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"gr[ae]y\s\S+?[\s\p{P}]";
      string input = "The gray wolf jumped over the grey wall.";
      MatchCollection matches = Regex.Matches(input, pattern);
      foreach (Match match in matches)
         Console.WriteLine($"'{match.Value}'");
   }
}
// The example displays the following output:
//       'gray wolf '
//       'grey wall.'

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "gr[ae]y\s\S+?[\s\p{P}]"
        Dim input As String = "The gray wolf jumped over the grey wall."
        Dim matches As MatchCollection = Regex.Matches(input, pattern)
        For Each match As Match In matches
            Console.WriteLine($"'{match.Value}'")
        Next
    End Sub
End Module
' The example displays the following output:
'       'gray wolf '
'       'grey wall.'

Pola ekspresi reguler gr[ae]y\s\S+?[\s|\p{P}] didefinisikan seperti berikut:

Pola Deskripsi
gr Cocokkan karakter harfiah "gr".
[ae] Cocokkan "a" atau "e".
y\s Cocokkan karakter harfiah "y" diikuti oleh karakter spasi kosong.
\S+? Cocokkan satu atau lebih karakter nonspasi kosong, tetapi sesedikit mungkin.
[\s\p{P}] Cocokkan karakter spasi kosong atau tanda baca.

Contoh berikut ini cocok dengan kata-kata yang dimulai dengan huruf kapital apa pun. Contoh ini menggunakan subekspresi [A-Z] untuk mewakili rentang huruf kapital dari A hingga Z.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b[A-Z]\w*\b";
      string input = "A city Albany Zulu maritime Marseilles";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       A
//       Albany
//       Zulu
//       Marseilles

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b[A-Z]\w*\b"
        Dim input As String = "A city Albany Zulu maritime Marseilles"
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
        Next
    End Sub
End Module

Regex \b[A-Z]\w*\b didefinisikan seperti yang ditunjukkan pada tabel berikut.

Pola Deskripsi
\b Mulailah dari batas kata.
[A-Z] Cocokkan karakter huruf besar apa pun dari A hingga Z.
\w* Mencocokkan nol atau beberapa karakter kata.
\b Cocokkan batas kata.

Grup karakter negatif: [^]

Grup karakter negatif menentukan daftar karakter yang tidak boleh muncul pada string input agar kecocokan terjadi. Daftar karakter bisa ditentukan secara individual, sebagai rentang, atau keduanya.

Sintaks untuk menentukan daftar karakter individual adalah sebagai berikut:

[*^character_group*]

di mana character_group adalah daftar karakter individual yang bisa muncul pada string input agar kecocokan berhasil. character_group bisa terdiri dari kombinasi satu atau beberapa karakter harfiah, karakter escape, atau kelas karakter.

Sintaks untuk menentukan rentang karakter adalah sebagai berikut:

[^*firstCharacter*-*lastCharacter*]

di mana firstCharacter adalah karakter yang memulai rentang dan lastCharacter adalah karakter yang mengakhiri rentang tersebut. Rentang karakter adalah serangkaian karakter berdekatan yang didefinisikan dengan menentukan karakter pertama dalam seri, tanda hubung (-), dan karakter terakhir dalam seri. Dua karakter disebut bersebelahan jika mereka memiliki titik kode Unicode yang berdekatan. firstCharacter harus berupa karakter dengan titik kode yang lebih rendah, dan lastCharacter harus berupa karakter dengan titik kode yang lebih tinggi.

Catatan

Karena grup karakter negatif bisa mencakup sekumpulan karakter dan rentang karakter, karakter tanda hubung (-) selalu ditafsirkan sebagai pemisah rentang kecuali itu adalah karakter pertama atau terakhir dari grup.

Dua atau beberapa rentang karakter bisa digabungkan. Misalnya, untuk menentukan rentang digit desimal dari "0" hingga "9", rentang huruf kecil dari "a" hingga "f", dan rentang huruf besar dari "A" hingga "F", digunakanlah [0-9a-fA-F].

Karakter tanda sisipan utama (^) dalam grup karakter negatif bersifat wajib dan menunjukkan bahwa grup karakter adalah grup karakter negatif alih-alih grup karakter positif.

Penting

Kelompok karakter negatif pada pola ekspresi reguler yang lebih besar bukanlah pernyataan lebar nol. Artinya, setelah mengevaluasi kelompok karakter negatif, mesin ekspresi reguler memajukan satu karakter pada string input.

Beberapa pola ekspresi reguler umum yang berisi kelompok karakter negatif tercantum dalam tabel berikut ini.

Pola Deskripsi
[^aeiou] Cocokkan semua karakter kecuali huruf hidup.
[^\p{P}\d] Cocokkan semua karakter kecuali tanda baca dan karakter digit desimal.

Contoh berikut ini cocok dengan kata apa pun yang dimulai dengan karakter "th" dan tidak diikuti oleh "o".

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\bth[^o]\w+\b";
      string input = "thought thing though them through thus thorough this";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       thing
//       them
//       through
//       thus
//       this

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\bth[^o]\w+\b"
        Dim input As String = "thought thing though them through thus " + _
                              "thorough this"
        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:
'       thing
'       them
'       through
'       thus
'       this

Regex \bth[^o]\w+\b didefinisikan seperti yang ditunjukkan pada tabel berikut.

Pola Deskripsi
\b Mulailah dari batas kata.
th Cocokkan karakter harfiah "gr".
[^o] Cocokkan karakter apa pun yang bukan "o".
\w+ Mencocokkan satu atau beberapa karakter kata.
\b Berakhir pada batas kata.

Karakter apa pun.

Karakter titik (.) cocok dengan karakter apa pun kecuali \n (karakter baris baru), dengan dua kualifikasi berikut:

  • Jika pola ekspresi reguler dimodifikasi oleh opsi RegexOptions.Singleline, atau jika bagian pola yang berisi kelas karakter . dimodifikasi oleh opsi s, . cocok dengan karakter apa pun. Untuk informasi selengkapnya, lihat Opsi Ekspresi Reguler.

    Contoh berikut mengilustrasikan perilaku kelas karakter . yang berbeda secara default dan dengan 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 pengembalian pengangkutan, \r, 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\.

Catatan

Karena cocok dengan karakter apa pun kecuali \n, . kelas karakter juga cocok \r (karakter pengembalian pengangkutan).

  • Pada kelompok karakter positif atau negatif, titik diperlakukan sebagai karakter titik harfiah, dan bukan sebagai kelas karakter. Untuk informasi selengkapnya, lihat Grup Karakter Positif dan Grup Karakter Negatif sebelumnya pada topik ini. Contoh berikut ini memberikan ilustrasi dengan mendefinisikan ekspresi reguler yang menyertakan karakter titik (.) baik sebagai kelas karakter maupun sebagai anggota grup karakter positif. Ekspresi reguler \b.*[.?!;:](\s|\z) dimulai pada batas kata, cocok dengan karakter apa pun hingga menemukan salah satu dari lima tanda baca, termasuk titik, lalu cocok dengan karakter spasi kosong atau akhir string.

    using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b.*[.?!;:](\s|\z)";
      string input = "this. what: is? go, thing.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       this. what: is? go, thing.

    Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As STring = "\b.*[.?!;:](\s|\z)"
        Dim input As String = "this. what: is? go, thing."
        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. what: is? go, thing.

Catatan

Karena cocok dengan karakter apa pun, elemen bahasa . sering digunakan dengan kuantifier malas jika pola ekspresi reguler mencoba mencocokkan karakter apa pun beberapa kali. Untuk informasi selengkapnya, lihat Pembilang.

Kategori Unicode atau blok Unicode: \p{}

Standar Unicode menetapkan kategori umum pada setiap karakter. Misalnya, karakter tertentu dapat berupa huruf besar (diwakili oleh kategori Lu), digit desimal (kategori Nd), simbol matematika (kategori Sm), atau pemisah paragraf (kategori Zl). Set karakter tertentu pada standar Unicode juga menempati rentang atau blok titik kode berturut-turut tertentu. Contohnya, set karakter Latin dasar ditemukan dari \u0000 hingga \u007F, sedangkan set karakter Arab ditemukan dari \u0600 hingga \u06FF.

Konstruksi ekspresi reguler

\p{Nama }

cocok dengan karakter apa pun yang termasuk pada kategori umum Unicode atau blok bernama, di mana nama adalah singkatan kategori atau nama blok bernama. Untuk daftar singkatan kategori, lihat bagian Kategori Umum Unicode yang Didukung nanti pada topik ini. Untuk daftar blok bernama, lihat bagian Blok Bernama yang Didukung nanti dalam topik ini.

Tip

Pencocokan dapat ditingkatkan jika string pertama kali dinormalisasi dengan memanggil String.Normalize metode .

Contoh berikut ini menggunakan konstruksi \p{nama} untuk mencocokkan kategori umum Unicode (dalam hal ini, Pd, atau Tanda Baca, kategori Dash) dan blok bernama (blok bernama IsGreek dan IsBasicLatin).

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+";
      string input = "Κατα Μαθθαίον - The Gospel of Matthew";

      Console.WriteLine(Regex.IsMatch(input, pattern));        // Displays True.
   }
}

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+"
        Dim input As String = "Κατα Μαθθαίον - The Gospel of Matthew"

        Console.WriteLine(Regex.IsMatch(input, pattern))         ' Displays True.
    End Sub
End Module

Regex \b(\p{IsGreek}+(\s)?)+\p{Pd}\s(\p{IsBasicLatin}+(\s)?)+ didefinisikan seperti yang ditunjukkan pada tabel berikut.

Pola Deskripsi
\b Mulailah dari batas kata.
\p{IsGreek}+ Cocokkan satu atau beberapa karakter Yunani.
(\s)? Cocokkan nol atau satu karakter white space.
(\p{IsGreek}+(\s)?)+ Cocokkan pola satu atau lebih karakter Yunani diikuti dengan nol atau satu karakter ruang kosong satu kali atau lebih.
\p{Pd} Cocokkan dengan karakter Tanda Baca, Dash.
\s Cocokkan karakter spasi kosong.
\p{IsBasicLatin}+ Cocokkan satu atau lebih karakter Latin dasar.
(\s)? Cocokkan nol atau satu karakter white space.
(\p{IsBasicLatin}+(\s)?)+ Cocokkan pola satu atau beberapa karakter Latin dasar diikuti oleh nol atau satu karakter spasi kosong satu atau beberapa kali.

Kategori Unicode atau blok Unicode negatif: \p{}

Standar Unicode menetapkan kategori umum pada setiap karakter. Misalnya, karakter tertentu dapat berupa huruf besar (diwakili oleh kategori Lu), digit desimal (kategori Nd), simbol matematika (kategori Sm), atau pemisah paragraf (kategori Zl). Set karakter tertentu pada standar Unicode juga menempati rentang atau blok titik kode berturut-turut tertentu. Contohnya, set karakter Latin dasar ditemukan dari \u0000 hingga \u007F, sedangkan set karakter Arab ditemukan dari \u0600 hingga \u06FF.

Konstruksi ekspresi reguler

\P{Nama }

cocok dengan karakter apa pun yang termasuk dalam kategori umum Unicode atau blok bernama, di mana nama adalah singkatan kategori atau nama blok bernama. Untuk daftar singkatan kategori, lihat bagian Kategori Umum Unicode yang Didukung nanti pada topik ini. Untuk daftar blok bernama, lihat bagian Blok Bernama yang Didukung nanti dalam topik ini.

Tip

Pencocokan dapat ditingkatkan jika string pertama kali dinormalisasi dengan memanggil String.Normalize metode .

Contoh berikut ini menggunakan konstruksi \P{nama} untuk menghapus simbol mata uang apa pun (dalam hal ini, Sc, atau Simbol, kategori Mata Uang) dari string numerik.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\P{Sc})+";

      string[] values = { "$164,091.78", "£1,073,142.68", "73¢", "€120" };
      foreach (string value in values)
         Console.WriteLine(Regex.Match(value, pattern).Value);
   }
}
// The example displays the following output:
//       164,091.78
//       1,073,142.68
//       73
//       120

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(\P{Sc})+"

        Dim values() As String = {"$164,091.78", "£1,073,142.68", "73¢", "€120"}
        For Each value As String In values
            Console.WriteLine(Regex.Match(value, pattern).Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       164,091.78
'       1,073,142.68
'       73
'       120

Pola ekspresi reguler (\P{Sc})+ cocok dengan satu atau beberapa karakter yang bukan simbol mata uang; pola ekspresi reguler secara efektif menghapus simbol mata uang apa pun dari string hasil.

Karakter kata: \w

\w cocok dengan karakter kata apa pun. Karakter kata adalah anggota dari salah satu kategori Unicode yang tercantum pada tabel berikut ini.

Kategori Deskripsi
Ll Huruf, Huruf Kecil
Lu Huruf, Huruf Besar
Lt Huruf, Titlecase
Lo Huruf, Lainnya
Lm Huruf, Pengubah
Mn Tanda, Tanpa Spasi
Nd Angka, Digit Desimal
Pc Tanda baca, Konektor. Kategori ini mencakup sepuluh karakter, dan yang paling umum digunakan adalah karakter LOWLINE (_), u +005F.

Jika perilaku yang sesuai dengan ECMAScript ditentukan, maka \w setara dengan [a-zA-Z_0-9]. Untuk informasi tentang ekspresi reguler ECMAScript, lihat pada bagian "Perilaku Pencocokan ECMAScript" di Opsi Ekspresi Reguler.

Catatan

Karena cocok dengan karakter apa pun, elemen bahasa \w sering digunakan bersama dengan kuantifier malas jika pola ekspresi reguler mencoba mencocokkan karakter apa pun beberapa kali. Untuk informasi selengkapnya, lihat Pembilang.

Contoh berikut ini menggunakan elemen bahasa \w untuk mencocokkan karakter duplikat dalam sebuah kata. Contoh ini mendefinisikan pola ekspresi reguler, (\w)\1, yang dapat ditafsirkan sebagai berikut.

Elemen Deskripsi
(\w) Cocokkan karakter kata. Ini adalah grup penangkapan pertama.
\1 Cocokkan nilai pengambilan pertama. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"(\w)\1";
      string[] words = { "trellis", "seer", "latter", "summer",
                         "hoarse", "lesser", "aardvark", "stunned" };
      foreach (string word in words)
      {
         Match match = Regex.Match(word, pattern);
         if (match.Success)
            Console.WriteLine("'{0}' found in '{1}' at position {2}.",
                              match.Value, word, match.Index);
         else
            Console.WriteLine("No double characters in '{0}'.", word);
      }
   }
}
// The example displays the following output:
//       'll' found in 'trellis' at position 3.
//       'ee' found in 'seer' at position 1.
//       'tt' found in 'latter' at position 2.
//       'mm' found in 'summer' at position 2.
//       No double characters in 'hoarse'.
//       'ss' found in 'lesser' at position 2.
//       'aa' found in 'aardvark' at position 0.
//       'nn' found in 'stunned' at position 3.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "(\w)\1"
        Dim words() As String = {"trellis", "seer", "latter", "summer", _
                                  "hoarse", "lesser", "aardvark", "stunned"}
        For Each word As String In words
            Dim match As Match = Regex.Match(word, pattern)
            If match.Success Then
                Console.WriteLine("'{0}' found in '{1}' at position {2}.", _
                                  match.Value, word, match.Index)
            Else
                Console.WriteLine("No double characters in '{0}'.", word)
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       'll' found in 'trellis' at position 3.
'       'ee' found in 'seer' at position 1.
'       'tt' found in 'latter' at position 2.
'       'mm' found in 'summer' at position 2.
'       No double characters in 'hoarse'.
'       'ss' found in 'lesser' at position 2.
'       'aa' found in 'aardvark' at position 0.
'       'nn' found in 'stunned' at position 3.

Karakter nonkata: \W

\W cocok dengan karakter nonkata apa pun. Elemen bahasa \W setara dengan kelas karakter berikut ini:

[^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}\p{Lm}]

Dengan kata lain, ini cocok dengan karakter apa pun kecuali karakter pada kategori Unicode yang tercantum dalam tabel berikut.

Kategori Deskripsi
Ll Huruf, Huruf Kecil
Lu Huruf, Huruf Besar
Lt Huruf, Titlecase
Lo Huruf, Lainnya
Lm Huruf, Pengubah
Mn Tanda, Tanpa Spasi
Nd Angka, Digit Desimal
Pc Tanda baca, Konektor. Kategori ini mencakup sepuluh karakter, dan yang paling umum digunakan adalah karakter LOWLINE (_), u +005F.

Jika perilaku yang sesuai dengan ECMAScript ditentukan, maka \W setara dengan [^a-zA-Z_0-9]. Untuk informasi tentang ekspresi reguler ECMAScript, lihat pada bagian "Perilaku Pencocokan ECMAScript" di Opsi Ekspresi Reguler.

Catatan

Karena cocok dengan karakter apa pun, elemen bahasa \W sering digunakan bersama dengan kuantifier malas jika pola ekspresi reguler yang mencoba mencocokkan karakter apa pun beberapa kali. Untuk informasi selengkapnya, lihat Pembilang.

Contoh berikut ini mengilustrasikan kelas karakter \W. Contoh ini mendefinisikan pola ekspresi reguler, \b(\w+)(\W){1,2}, yang cocok dengan kata yang diikuti oleh satu atau dua karakter non-kata, seperti spasi kosong atau tanda baca. Regex ditafsirkan seperti yang diperlihatkan dalam tabel berikut ini.

Elemen Deskripsi
\b Memulai pencocokan dalam batas kata.
(\w+) Mencocokkan satu atau beberapa karakter kata. Ini adalah grup penangkapan pertama.
(\W){1,2} Cocokkan karakter nonkata satu atau dua kali. Ini adalah grup pengambilan kedua. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\w+)(\W){1,2}";
      string input = "The old, grey mare slowly walked across the narrow, green pasture.";
      foreach (Match match in Regex.Matches(input, pattern))
      {
         Console.WriteLine(match.Value);
         Console.Write("   Non-word character(s):");
         CaptureCollection captures = match.Groups[2].Captures;
         for (int ctr = 0; ctr < captures.Count; ctr++)
             Console.Write(@"'{0}' (\u{1}){2}", captures[ctr].Value,
                           Convert.ToUInt16(captures[ctr].Value[0]).ToString("X4"),
                           ctr < captures.Count - 1 ? ", " : "");
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//       The
//          Non-word character(s):' ' (\u0020)
//       old,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       grey
//          Non-word character(s):' ' (\u0020)
//       mare
//          Non-word character(s):' ' (\u0020)
//       slowly
//          Non-word character(s):' ' (\u0020)
//       walked
//          Non-word character(s):' ' (\u0020)
//       across
//          Non-word character(s):' ' (\u0020)
//       the
//          Non-word character(s):' ' (\u0020)
//       narrow,
//          Non-word character(s):',' (\u002C), ' ' (\u0020)
//       green
//          Non-word character(s):' ' (\u0020)
//       pasture.
//          Non-word character(s):'.' (\u002E)

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\w+)(\W){1,2}"
        Dim input As String = "The old, grey mare slowly walked across the narrow, green pasture."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Value)
            Console.Write("   Non-word character(s):")
            Dim captures As CaptureCollection = match.Groups(2).Captures
            For ctr As Integer = 0 To captures.Count - 1
                Console.Write("'{0}' (\u{1}){2}", captures(ctr).Value, _
                              Convert.ToUInt16(captures(ctr).Value.Chars(0)).ToString("X4"), _
                              If(ctr < captures.Count - 1, ", ", ""))
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
' The example displays the following output:
'       The
'          Non-word character(s):' ' (\u0020)
'       old,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       grey
'          Non-word character(s):' ' (\u0020)
'       mare
'          Non-word character(s):' ' (\u0020)
'       slowly
'          Non-word character(s):' ' (\u0020)
'       walked
'          Non-word character(s):' ' (\u0020)
'       across
'          Non-word character(s):' ' (\u0020)
'       the
'          Non-word character(s):' ' (\u0020)
'       narrow,
'          Non-word character(s):',' (\u002C), ' ' (\u0020)
'       green
'          Non-word character(s):' ' (\u0020)
'       pasture.
'          Non-word character(s):'.' (\u002E)

Karena objek Group untuk grup penangkapan kedua hanya berisi satu karakter nonkata yang diambil, contoh ini mengambil semua karakter nonkata yang diambil dari objek CaptureCollection yang dikembalikan oleh properti Group.Captures.

Karakter spasi kosong: \s

\s cocok dengan karakter spasi kosong apa pun. Ini setara dengan urutan escape dan kategori Unicode yang tercantum pada tabel berikut.

Kategori Deskripsi
\f Karakter umpan formulir, \u000C.
\n Karakter baris baru, \u000A.
\r Karakter kembali ke awal, \u000D.
\t Karakter tab, \u0009.
\v Karakter tab vertikal, \u000B.
\x85 Karakter NEXT LINE (NEL), \u0085.
\p{Z} Cocok dengan semua karakter pemisah. Ini termasuk kategori Zs, Zl, dan Zp.

Jika perilaku yang sesuai dengan ECMAScript ditentukan, maka \s setara dengan [ \f\n\r\t\v]. Untuk informasi tentang ekspresi reguler ECMAScript, lihat pada bagian "Perilaku Pencocokan ECMAScript" di Opsi Ekspresi Reguler.

Contoh berikut ini mengilustrasikan kelas karakter \s. Contoh ini mendefinisikan pola ekspresi reguler, \b\w+(e)?s(\s|$), yang cocok dengan kata yang berakhiran "s" atau "es" diikuti oleh karakter spasi putih atau akhir string input. Regex ditafsirkan seperti yang diperlihatkan dalam tabel berikut ini.

Elemen Deskripsi
\b Memulai pencocokan dalam batas kata.
\w+ Mencocokkan satu atau beberapa karakter kata.
(e)? Cocokkan "e" baik nol atau satu kali.
s Cocokkan dengan "s".
(\s|$) Cocokkan karakter spasi kosong atau akhir string input. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b\w+(e)?s(\s|$)";
      string input = "matches stores stops leave leaves";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Value);
   }
}
// The example displays the following output:
//       matches
//       stores
//       stops
//       leaves

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b\w+(e)?s(\s|$)"
        Dim input As String = "matches stores stops leave leaves"
        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:
'       matches
'       stores
'       stops
'       leaves

Karakter nonspasi kosong: \S

\S cocok dengan karakter nonspasi kosong apa pun. Ini setara dengan pola ekspresi reguler [^\f\n\r\t\v\x85\p{Z}], atau kebalikan dari pola ekspresi reguler yang setara dengan \s, yang cocok dengan karakter spasi kosong. Untuk informasi lebih lanjut, lihat Karakter Spasi Kosong: \s.

Jika perilaku yang sesuai dengan ECMAScript ditentukan, maka \S setara dengan [^ \f\n\r\t\v]. Untuk informasi tentang ekspresi reguler ECMAScript, lihat pada bagian "Perilaku Pencocokan ECMAScript" di Opsi Ekspresi Reguler.

Contoh berikut ini mengilustrasikan elemen bahasa \S. Pola ekspresi reguler \b(\S+)\s? cocok dengan string yang dibatasi oleh karakter spasi kosong. Elemen kedua dalam objek kecocokan GroupCollection berisi string yang cocok. Ekspresi reguler dapat ditafsirkan seperti yang ditunjukkan pada tabel berikut ini.

Elemen Deskripsi
\b Memulai pencocokan dalam batas kata.
(\S+) Cocokkan satu atau beberapa karakter nonspasi kosong. Ini adalah grup penangkapan pertama.
\s? Cocokkan nol atau satu karakter white space. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"\b(\S+)\s?";
      string input = "This is the first sentence of the first paragraph. " +
                            "This is the second sentence.\n" +
                            "This is the only sentence of the second paragraph.";
      foreach (Match match in Regex.Matches(input, pattern))
         Console.WriteLine(match.Groups[1]);
   }
}
// The example displays the following output:
//    This
//    is
//    the
//    first
//    sentence
//    of
//    the
//    first
//    paragraph.
//    This
//    is
//    the
//    second
//    sentence.
//    This
//    is
//    the
//    only
//    sentence
//    of
//    the
//    second
//    paragraph.

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "\b(\S+)\s?"
        Dim input As String = "This is the first sentence of the first paragraph. " + _
                              "This is the second sentence." + vbCrLf + _
                              "This is the only sentence of the second paragraph."
        For Each match As Match In Regex.Matches(input, pattern)
            Console.WriteLine(match.Groups(1))
        Next
    End Sub
End Module
' The example displays the following output:
'    This
'    is
'    the
'    first
'    sentence
'    of
'    the
'    first
'    paragraph.
'    This
'    is
'    the
'    second
'    sentence.
'    This
'    is
'    the
'    only
'    sentence
'    of
'    the
'    second
'    paragraph.

Karakter digit desimal: \d

\d cocok dengan digit desimal. Ini setara dengan pola ekspresi reguler \p{Nd}, yang mencakup digit desimal standar 0-9 serta digit desimal dari sejumlah set karakter lainnya.

Jika perilaku yang sesuai dengan ECMAScript ditentukan, maka \d setara dengan [0-9]. Untuk informasi tentang ekspresi reguler ECMAScript, lihat pada bagian "Perilaku Pencocokan ECMAScript" di Opsi Ekspresi Reguler.

Contoh berikut ini mengilustrasikan elemen bahasa \d. Contoh ini menguji apakah string input mewakili nomor telepon yang valid di Amerika Serikat dan Kanada. Pola regex ^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$ didefinisikan seperti yang ditunjukkan pada tabel berikut.

Elemen Deskripsi
^ Mulai pencocokan di awal string input.
\(? Cocokkan nol atau satu karakter "(" harfiah.
\d{3} Cocokkan tiga digit desimal.
\)? Cocokkan nol atau satu karakter ")" harfiah.
[\s-] Cocokkan tanda hubung atau karakter spasi kosong.
(\(?\d{3}\)?[\s-])? Cocokkan tanda kurung buka opsional yang diikuti oleh tiga digit desimal, tanda kurung tutup opsional, dan karakter spasi kosong atau tanda hubung nol atau satu kali. Ini adalah grup penangkapan pertama.
\d{3}-\d{4} Cocokkan tiga digit desimal yang diikuti dengan tanda hubung dan empat digit desimal lagi.
$ Cocokkan akhir string input. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$";
      string[] inputs = { "111 111-1111", "222-2222", "222 333-444",
                          "(212) 111-1111", "111-AB1-1111",
                          "212-111-1111", "01 999-9999" };

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       111 111-1111: matched
//       222-2222: matched
//       222 333-444: match failed
//       (212) 111-1111: matched
//       111-AB1-1111: match failed
//       212-111-1111: matched
//       01 999-9999: match failed

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^(\(?\d{3}\)?[\s-])?\d{3}-\d{4}$"
        Dim inputs() As String = {"111 111-1111", "222-2222", "222 333-444", _
                                   "(212) 111-1111", "111-AB1-1111", _
                                   "212-111-1111", "01 999-9999"}

        For Each input As String In inputs
            If Regex.IsMatch(input, pattern) Then
                Console.WriteLine(input + ": matched")
            Else
                Console.WriteLine(input + ": match failed")
            End If
        Next
    End Sub
End Module
' The example displays the following output:
'       111 111-1111: matched
'       222-2222: matched
'       222 333-444: match failed
'       (212) 111-1111: matched
'       111-AB1-1111: match failed
'       212-111-1111: matched
'       01 999-9999: match failed

Karakter nondigit: \D

\D cocok dengan karakter nondigit apa pun. Ini setara dengan pola ekspresi reguler \P{Nd}.

Jika perilaku yang sesuai dengan ECMAScript ditentukan, maka \D setara dengan [^0-9]. Untuk informasi tentang ekspresi reguler ECMAScript, lihat pada bagian "Perilaku Pencocokan ECMAScript" di Opsi Ekspresi Reguler.

Contoh berikut ini mengilustrasikan elemen bahasa \D. Contoh ini menguji apakah string seperti nomor bagian terdiri dari kombinasi karakter desimal dan non-desimal yang sesuai. Pola regex ^\D\d{1,5}\D*$ didefinisikan seperti yang ditunjukkan pada tabel berikut.

Elemen Deskripsi
^ Mulai pencocokan di awal string input.
\D Cocokkan dengan karakter nondigit.
\d{1,5} Cocokkan dari satu hingga lima digit desimal.
\D* Cocokkan karakter nol, satu, atau lebih nondesimal.
$ Cocokkan akhir string input. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string pattern = @"^\D\d{1,5}\D*$";
      string[] inputs = { "A1039C", "AA0001", "C18A", "Y938518" };

      foreach (string input in inputs)
      {
         if (Regex.IsMatch(input, pattern))
            Console.WriteLine(input + ": matched");
         else
            Console.WriteLine(input + ": match failed");
      }
   }
}
// The example displays the following output:
//       A1039C: matched
//       AA0001: match failed
//       C18A: matched
//       Y938518: match failed

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim pattern As String = "^\D\d{1,5}\D*$"
        Dim inputs() As String = {"A1039C", "AA0001", "C18A", "Y938518"}

        For Each input As String In inputs
            If Regex.IsMatch(input, pattern) Then
                Console.WriteLine(input + ": matched")
            Else
                Console.WriteLine(input + ": match failed")
            End If
        Next
    End Sub
End Module
' The example displays the following output:

Kategori umum Unicode yang didukung

Unicode menentukan kategori umum yang tercantum pada tabel berikut. Untuk informasi selengkapnya, lihat subtopik "Format File UCD" dan "Nilai Kategori Umum" di Database Karakter Unicode, Bag. 5.7.1, Tabel 12.

Kategori Deskripsi
Lu Huruf, Huruf Besar
Ll Huruf, Huruf Kecil
Lt Huruf, Titlecase
Lm Huruf, Pengubah
Lo Huruf, Lainnya
L Semua karakter huruf. Ini termasuk karakter Lu, Ll, Lt, Lm, dan Lo.
Mn Tanda, Tanpa Spasi
Mc Tanda, Penggabungan Spasi
Me Tanda, Penutup
M Semua tanda kombinasi. Ini termasuk kategori Mn, Mc, dan Me.
Nd Angka, Digit Desimal
Nl Angka, Huruf
No Angka, Lainnya
N Semua angka. Ini termasuk kategori Nd, Nl, dan No.
Pc Tanda Baca, Konektor
Pd Tanda Baca, Garis Putus
Ps Tanda baca, Buka
Pe Tanda baca, Tutup
Pi Tanda baca, Kutipan awal (mungkin berperilaku seperti Ps atau Pe tergantung pada penggunaannya)
Pf Tanda baca, Kutipan akhir (mungkin berperilaku seperti Ps atau Pe tergantung pada penggunaannya)
Po Tanda Baca, Lainnya
P Semua karakter tanda baca. Ini termasuk kategori Pc, Pd, Ps, Pe, Pi, Pf, dan Po.
Sm Simbol, Matematika
Sc Simbol, Mata Uang
Sk Simbol, Pengubah
So Simbol, Lainnya
S Semua simbol. Ini termasuk kategori Sm, Sc, Sk, dan So.
Zs Pemisah, Spasi
Zl Pemisah, Garis
Zp Pemisah, Paragraf
Z Semua karakter pemisah. Ini termasuk kategori Zs, Zl, dan Zp.
Cc Lainnya, Kontrol
Cf Lainnya, Format
Cs Lainnya, Pengganti
Co Lainnya, Penggunaan Privat
Cn Lainnya, Tidak Ditetapkan atau Nonkarakter
C Semua karakter lain. Ini termasuk kategori Cc, Cf, Cs, Co, dan Cn.

Anda bisa menentukan kategori Unicode dari karakter tertentu dengan meneruskan karakter tersebut ke metode GetUnicodeCategory. Contoh berikut ini menggunakan metode GetUnicodeCategory untuk menentukan kategori setiap elemen dalam array yang berisi karakter Latin yang dipilih.

using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      char[] chars = { 'a', 'X', '8', ',', ' ', '\u0009', '!' };

      foreach (char ch in chars)
         Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()),
                           Char.GetUnicodeCategory(ch));
   }
}
// The example displays the following output:
//       'a': LowercaseLetter
//       'X': UppercaseLetter
//       '8': DecimalDigitNumber
//       ',': OtherPunctuation
//       '\ ': SpaceSeparator
//       '\t': Control
//       '!': OtherPunctuation

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim chars() As Char = {"a"c, "X"c, "8"c, ","c, " "c, ChrW(9), "!"c}

        For Each ch As Char In chars
            Console.WriteLine("'{0}': {1}", Regex.Escape(ch.ToString()), _
                              Char.GetUnicodeCategory(ch))
        Next
    End Sub
End Module
' The example displays the following output:
'       'a': LowercaseLetter
'       'X': UppercaseLetter
'       '8': DecimalDigitNumber
'       ',': OtherPunctuation
'       '\ ': SpaceSeparator
'       '\t': Control
'       '!': OtherPunctuation

Blok bernama yang didukung

.NET menyediakan blok bernama yang tercantum dalam tabel berikut ini. Kumpulan blok bernama yang didukung berdasarkan pada Unicode 4.0 dan Perl 5.6. Untuk ekspresi reguler yang menggunakan blok bernama, lihat bagian kategori Unicode atau blok Unicode: \p{}.

Rentang titik kode Nama blok
0000 - 007F IsBasicLatin
0080 - 00FF IsLatin-1Supplement
0100 - 017F IsLatinExtended-A
0180 - 024F IsLatinExtended-B
0250 - 02AF IsIPAExtensions
02B0 - 02FF IsSpacingModifierLetters
0300 - 036F IsCombiningDiacriticalMarks
0370 - 03FF IsGreek

-atau-

IsGreekandCoptic
0400 - 04FF IsCyrillic
0500 - 052F IsCyrillicSupplement
0530 - 058F IsArmenian
0590 - 05FF IsHebrew
0600 - 06FF IsArabic
0700 - 074F IsSyriac
0780 - 07BF IsThaana
0900 - 097F IsDevanagari
0980 - 09FF IsBengali
0A00 - 0A7F IsGurmukhi
0A80 - 0AFF IsGujarati
0B00 - 0B7F IsOriya
0B80 - 0BFF IsTamil
0C00 - 0C7F IsTelugu
0C80 - 0CFF IsKannada
0D00 - 0D7F IsMalayalam
0D80 - 0DFF IsSinhala
0E00 - 0E7F IsThai
0E80 - 0EFF IsLao
0F00 - 0FFF IsTibetan
1000 - 109F IsMyanmar
10A0 - 10FF IsGeorgian
1100 - 11FF IsHangulJamo
1200 - 137F IsEthiopic
13A0 - 13FF IsCherokee
1400 - 167F IsUnifiedCanadianAboriginalSyllabics
1680 - 169F IsOgham
16A0 - 16FF IsRunic
1700 - 171F IsTagalog
1720 - 173F IsHanunoo
1740 - 175F IsBuhid
1760 - 177F IsTagbanwa
1780 - 17FF IsKhmer
1800 - 18AF IsMongolian
1900 - 194F IsLimbu
1950 - 197F IsTaiLe
19E0 - 19FF IsKhmerSymbols
1D00 - 1D7F IsPhoneticExtensions
1E00 - 1EFF IsLatinExtendedAdditional
1F00 - 1FFF IsGreekExtended
2000 - 206F IsGeneralPunctuation
2070 - 209F IsSuperscriptsandSubscripts
20A0 - 20CF IsCurrencySymbols
20D0 - 20FF IsCombiningDiacriticalMarksforSymbols

-atau-

IsCombiningMarksforSymbols
2100 - 214F IsLetterlikeSymbols
2150 - 218F IsNumberForms
2190 - 21FF IsArrows
2200 - 22FF IsMathematicalOperators
2300 - 23FF IsMiscellaneousTechnical
2400 - 243F IsControlPictures
2440 - 245F IsOpticalCharacterRecognition
2460 - 24FF IsEnclosedAlphanumerics
2500 - 257F IsBoxDrawing
2580 - 259F IsBlockElements
25A0 - 25FF IsGeometricShapes
2600 - 26FF IsMiscellaneousSymbols
2700 - 27BF IsDingbats
27C0 - 27EF IsMiscellaneousMathematicalSymbols-A
27F0 - 27FF IsSupplementalArrows-A
2800 - 28FF IsBraillePatterns
2900 - 297F IsSupplementalArrows-B
2980 - 29FF IsMiscellaneousMathematicalSymbols-B
2A00 - 2AFF IsSupplementalMathematicalOperators
2B00 - 2BFF IsMiscellaneousSymbolsandArrows
2E80 - 2EFF IsCJKRadicalsSupplement
2F00 - 2FDF IsKangxiRadicals
2FF0 - 2FFF IsIdeographicDescriptionCharacters
3000 - 303F IsCJKSymbolsandPunctuation
3040 - 309F IsHiragana
30A0 - 30FF IsKatakana
3100 - 312F IsBopomofo
3130 - 318F IsHangulCompatibilityJamo
3190 - 319F IsKanbun
31A0 - 31BF IsBopomofoExtended
31F0 - 31FF IsKatakanaPhoneticExtensions
3200 - 32FF IsEnclosedCJKLettersandMonths
3300 - 33FF IsCJKCompatibility
3400 - 4DBF IsCJKUnifiedIdeographsExtensionA
4DC0 - 4DFF IsYijingHexagramSymbols
4E00 - 9FFF IsCJKUnifiedIdeographs
A000 - A48F IsYiSyllables
A490 - A4CF IsYiRadicals
AC00 - D7AF IsHangulSyllables
D800 - DB7F IsHighSurrogates
DB80 - DBFF IsHighPrivateUseSurrogates
DC00 - DFFF IsLowSurrogates
E000 - F8FF IsPrivateUse atau IsPrivateUseArea
F900 - FAFF IsCJKCompatibilityIdeographs
FB00 - FB4F IsAlphabeticPresentationForms
FB50 - FDFF IsArabicPresentationForms-A
FE00 - FE0F IsVariationSelectors
FE20 - FE2F IsCombiningHalfMarks
FE30 - FE4F IsCJKCompatibilityForms
FE50 - FE6F IsSmallFormVariants
FE70 - FEFF IsArabicPresentationForms-B
FF00 - FFEF IsHalfwidthandFullwidthForms
FFF0 - FFFF IsSpecials

Pengurangan kelas karakter: [base_group - [excluded_group]]

Kelas karakter mendefinisikan satu set karakter. Pengurangan kelas karakter menghasilkan sekumpulan karakter yang merupakan hasil dari mengecualikan karakter pada satu kelas karakter dari kelas karakter lain.

Ekspresi pengurangan kelas karakter memiliki bentuk berikut ini:

[ -[ base_group excluded_group ]]

Tanda kurung siku ([]) dan tanda hubung (-) sifatnya wajib. base_group adalah grup karakter positif atau grup karakter negatif. Komponen excluded_group adalah grup karakter positif atau negatif lainnya, atau ekspresi pengurangan kelas karakter lainnya (artinya, Anda bisa menumpuk ekspresi pengurangan kelas karakter).

Misalnya, Anda mempunyai grup dasar yang terdiri dari rentang karakter dari "a" hingga "z". Untuk menentukan sekumpulan karakter yang terdiri dari grup dasar kecuali untuk karakter "m", maka gunakan [a-z-[m]]. Untuk menentukan sekumpulan karakter yang terdiri dari grup dasar kecuali untuk set karakter "d", “j”, dan “p”, maka gunakan [a-z-[djp]]. Untuk menentukan sekumpulan karakter yang terdiri dari grup dasar kecuali untuk rentang karakter dari "m" hingga “p”, maka gunakan [a-z-[m-p]].

Pertimbangkanlah ekspresi pengurangan kelas karakter berlapis, [a-z-[d-w-[m-o]]]. Ekspresi tersebut dievaluasi dari rentang karakter terdalam ke luar. Pertama-tama, karakter berkisar dari "m" hingga "o" dikurangi dari rentang karakter "d" hingga "w", yang menghasilkan serangkaian karakter dari "d" melalui "l" dan "p" melalui "w". Set tersebut lalu dikurangi dari rentang karakter dari "a" hingga "z", yang menghasilkan serangkaian karakter [abcmnoxyz].

Anda bisa menggunakan kelas karakter apa pun dengan pengurangan kelas karakter. Untuk menentukan sekumpulan karakter yang terdiri dari semua karakter Unicode dari \u0000 hingga \uFFFF kecuali karakter spasi kosong (\s), karakter dalam kategori umum tanda baca (\p{P}), karakter dalam IsGreek bernama blok (\p{IsGreek}), dan karakter kontrol Unicode NEXT LINE (\x85), gunakan [\u0000-\uFFFF-[\s\p{P}\p{IsGreek}\x85]].

Pilihlah kelas karakter untuk ekspresi pengurangan kelas karakter yang akan menghasilkan hasil yang berguna. Hindari ekspresi yang menghasilkan satu set karakter kosong, yang tidak dapat cocok dengan apa pun, atau ekspresi yang setara dengan grup dasar asli. Misalnya, set kosong adalah hasil dari ekspresi [\p{IsBasicLatin}-[\x00-\x7F]], yang mengurangi semua karakter dalam rentang karakter IsBasicLatin dari kategori umum IsBasicLatin. Demikian pula, grup dasar original adalah hasil dari ekspresi [a-z-[0-9]]. Ini dikarenakan grup dasar, yang merupakan rentang karakter huruf dari "a" hingga "z", tidak berisi karakter apa pun dalam grup yang dikecualikan, yang merupakan rentang karakter digit desimal dari "0" hingga "9".

Contoh berikut ini mendefinisikan ekspresi reguler, ^[0-9-[2468]]+$, yang cocok dengan digit nol dan ganjil dalam string input. Regex ditafsirkan seperti yang diperlihatkan dalam tabel berikut ini.

Elemen Deskripsi
^ Mulai pencocokan di awal string input.
[0-9-[2468]]+ Cocokkan satu atau lebih kejadian karakter apa pun dari 0 hingga 9 kecuali 2, 4, 6, dan 8. Dengan kata lain, cocokkan satu atau lebih kejadian nol atau digit ganjil.
$ Akhiri kecocokan di akhir string input. 
using System;
using System.Text.RegularExpressions;

public class Example
{
   public static void Main()
   {
      string[] inputs = { "123", "13579753", "3557798", "335599901" };
      string pattern = @"^[0-9-[2468]]+$";

      foreach (string input in inputs)
      {
         Match match = Regex.Match(input, pattern);
         if (match.Success)
            Console.WriteLine(match.Value);
      }
   }
}
// The example displays the following output:
//       13579753
//       335599901

Imports System.Text.RegularExpressions

Module Example
    Public Sub Main()
        Dim inputs() As String = {"123", "13579753", "3557798", "335599901"}
        Dim pattern As String = "^[0-9-[2468]]+$"

        For Each input As String In inputs
            Dim match As Match = Regex.Match(input, pattern)
            If match.Success Then Console.WriteLine(match.Value)
        Next
    End Sub
End Module
' The example displays the following output:
'       13579753
'       335599901

Lihat juga