Kelas karakter di dalam ekspresi reguler
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 opsis,.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, Lowercase |
| 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, Lowercase |
| 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, Lowercase |
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
Saran dan Komentar
Segera hadir: Sepanjang tahun 2024 kami akan menghentikan penggunaan GitHub Issues sebagai mekanisme umpan balik untuk konten dan menggantinya dengan sistem umpan balik baru. Untuk mengetahui informasi selengkapnya, lihat: https://aka.ms/ContentUserFeedback.
Kirim dan lihat umpan balik untuk