Catatan
Akses ke halaman ini memerlukan otorisasi. Anda dapat mencoba masuk atau mengubah direktori.
Akses ke halaman ini memerlukan otorisasi. Anda dapat mencoba mengubah direktori.
Konstruksi pengelompokan menggambarkan subekspresi dari ekspresi reguler dan mengambil substring dari string input. Anda dapat menggunakan konstruksi pengelompokan untuk melakukan hal berikut:
- Cocokkan subekspresi yang diulang dalam string input.
- Terapkan pembilang ke subekspresi yang memiliki beberapa elemen bahasa regex. Untuk informasi selengkapnya tentang pembilang, lihat Pembilang.
- Sertakan subekspresi dalam string yang dikembalikan oleh metode Regex.Replace dan Match.Result.
- Ambil subekspresi individual dari properti Match.Groups dan proses secara terpisah dari teks yang cocok secara keseluruhan.
Tabel berikut mencantumkan konstruk pengelompokan yang didukung oleh mesin ekspresi reguler .NET dan menunjukkan apakah mereka menangkap atau tidak.
| Pengelompokan konstruksi | Menangkap atau tidak menangkap |
|---|---|
| Subekspresi yang sesuai | Menangkap |
| Subekspresi bernama yang sesuai | Menangkap |
| Definisi grup penyeimbang | Menangkap |
| Grup yang tidak menangkap | Tidak menangkap |
| Opsi Kelompok | Tidak menangkap |
| Pernyataan antisipasi positif tanpa lebar | Tidak menangkap |
| Pernyataan lookahead negatif lebar-nol | Tidak menangkap |
| Pernyataan sandi belakang positif tanpa lebar | Tidak menangkap |
| Pernyataan lookbehind negatif dengan lebar nol | Tidak menangkap |
| Grup atomik | Tanpa penangkapan |
Untuk informasi tentang grup dan model objek regex, lihat Konstruksi pengelompokan dan objek regex.
Subekspresi yang cocok
Konstruksi pengelompokan berikut menangkap subekspresi yang cocok:
(
subekspresi)
Di sini, subekspresi adalah pola ekspresi reguler yang valid. Pengambilan yang menggunakan tanda kurung diberi nomor secara otomatis dari kiri ke kanan berdasarkan urutan tanda kurung pembuka dalam ekspresi reguler, mulai dari 1. Namun, grup tangkap bernama selalu ditempatkan setelah grup tangkap non-bernama. Tangkapan yang bernomor 0 adalah teks yang cocok dengan seluruh pola ekspresi reguler.
Catatan
Secara default, elemen bahasa (subekspresi) menangkap subekspresi yang cocok. Tetapi jika parameter RegexOptions dari metode pencocokan pola ekspresi reguler menyertakan flag RegexOptions.ExplicitCapture, atau jika opsi n diterapkan ke subekspresi ini (lihat Opsi grup nanti dalam artikel ini), subekspresi yang cocok tidak ditangkap.
Anda dapat mengakses grup yang ditangkap dengan empat cara:
Dengan menggunakan konstruksi referensi balik dalam ekspresi reguler. Subekspresi yang cocok direferensikan dalam regex yang sama dengan menggunakan sintaks
\angka, di mana angka adalah angka ordinal dari subekspresi yang diambil.Dengan menggunakan konstruksi referensi balik bernama dalam ekspresi reguler. Subekspresi yang cocok direferensikan dalam regex yang sama dengan menggunakan sintaks
\k<nama>, di mana nama adalah nama grup penangkapan, atau\k<angka>, di mana angka adalah angka ordinal dari grup penangkapan. Grup penangkap memiliki nama default yang identik dengan angka ordinalnya. Untuk informasi lebih lanjut, lihat Subekspresi bernama yang cocok di bawah topik ini.Dengan menggunakan urutan penggantian
$angka dalam panggilan metode Regex.Replace atau Match.Result, di mana angka adalah angka ordinal subekspresi yang diambil.Secara terprogram, dengan menggunakan objek GroupCollection yang dikembalikan oleh properti Match.Groups. Anggota pada posisi nol dalam koleksi mewakili seluruh kecocokan ekspresi reguler. Setiap anggota berikutnya mewakili subekspresi yang cocok. Untuk informasi selengkapnya, lihat bagian Konstruksi Pengelompokan dan Objek Regex.
Contoh berikut menggambarkan regex yang mengidentifikasi kata-kata duplikat dalam teks. Dua grup penangkap dari pola ekspresi reguler mewakili dua kemunculan kata yang diduplikasi. Instans kedua ditangkap untuk melaporkan posisi awalnya dalam string input.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(\w+)\s(\1)\W";
string input = "He said that that was the the correct answer.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
Console.WriteLine($"Duplicate '{match.Groups[1].Value}' found at positions {match.Groups[1].Index} and {match.Groups[2].Index}.");
}
}
// The example displays the following output:
// Duplicate 'that' found at positions 8 and 13.
// Duplicate 'the' found at positions 22 and 26.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(\w+)\s(\1)\W"
Dim input As String = "He said that that was the the correct answer."
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
Console.WriteLine("Duplicate '{0}' found at positions {1} and {2}.", _
match.Groups(1).Value, match.Groups(1).Index, match.Groups(2).Index)
Next
End Sub
End Module
' The example displays the following output:
' Duplicate 'that' found at positions 8 and 13.
' Duplicate 'the' found at positions 22 and 26.
Pola regex-nya adalah sebagai berikut:
(\w+)\s(\1)\W
Tabel berikut menunjukkan bagaimana pola regex ditafsirkan.
| Pola | Deskripsi |
|---|---|
(\w+) |
Mencocokkan satu atau beberapa karakter kata. Ini adalah grup penangkapan pertama. |
\s |
Cocokkan karakter spasi kosong. |
(\1) |
Cocokkan string dalam grup pertama yang ditangkap. Ini adalah kelompok penangkapan kedua. Contoh menetapkannya ke grup yang diambil sehingga posisi awal kata duplikat dapat diambil dari properti Match.Index. |
\W |
Cocokkan karakter non-kata, termasuk spasi dan tanda baca. Ini mencegah pola ekspresi reguler dari mencocokkan kata yang dimulai dengan kata dari kelompok pertama yang tertangkap. |
Subekspresi bernama yang cocok
Konstruksi pengelompokan berikut menangkap subekspresi yang cocok dan memungkinkan Anda mengaksesnya menurut nama atau nomor:
(?<name>subexpression)
atau:
(?'name'subexpression)
Di sini, nama adalah nama grup yang valid, dan subekspresi adalah pola ekspresi reguler yang valid. nama tidak boleh berisi karakter tanda baca apa pun dan tidak dapat dimulai dengan angka.
Catatan
Tetapi jika parameter RegexOptions dari metode pencocokan pola regex menyertakan bendera RegexOptions.ExplicitCapture, atau jika opsi n diterapkan ke subekspresi ini (lihat Opsi grup nanti dalam topik ini), satu-satunya cara untuk menangkap subekspresi adalah dengan secara eksplisit memberi nama grup penangkapan.
Anda dapat mengakses grup bernama yang diambil dengan cara berikut:
Dengan menggunakan konstruksi referensi balik bernama dalam regex. Subekspresi yang cocok direferensikan dalam regex yang sama dengan menggunakan sintaks
\k<nama>, di mana nama adalah nama dari subekspresi yang diambil.Dengan menggunakan konstruksi referensi balik dalam ekspresi reguler. Subekspresi yang cocok direferensikan dalam regex yang sama dengan menggunakan sintaks
\angka, di mana angka adalah angka ordinal dari subekspresi yang diambil. Subekspresi bernama yang cocok diberi nomor berturut-turut dari kiri ke kanan setelah subekspresi yang cocok.Dengan menggunakan urutan penggantian
${nama}dalam panggilan metode Regex.Replace atau Match.Result, di mana nama adalah nama subekspresi yang ditangkap.Dengan menggunakan urutan penggantian
$angka dalam panggilan metode Regex.Replace atau Match.Result, di mana angka adalah angka ordinal subekspresi yang diambil.Secara terprogram, dengan menggunakan objek GroupCollection yang dikembalikan oleh properti Match.Groups. Anggota pada posisi nol dalam kumpulan mewakili seluruh kecocokan ekspresi reguler. Setiap anggota berikutnya mewakili subekspresi yang cocok. Grup bernama yang ditangkap disimpan dalam koleksi setelah grup yang ditangkap bernomor.
Secara terprogram, dengan memberikan nama subekspresi ke pengindeks objek GroupCollection (dalam C#) atau ke propertinya Item[] (dalam Visual Basic).
Pola regex sederhana menggambarkan bagaimana kelompok bernomor (tidak bernama) dan bernama dapat direferensikan baik secara terprogram atau dengan menggunakan sintaks bahasa regex. Regex ((?<One>abc)\d+)?(?<Two>xyz)(.*) menghasilkan grup pengambilan berikut menurut angka dan nama. Kelompok penangkap pertama (angka 0) selalu mengacu pada seluruh pola. (Grup bernama selalu diurutkan terakhir.)
| Nomor | Nama | Pola |
|---|---|---|
| 0 | 0 (nama default) | ((?<One>abc)\d+)?(?<Two>xyz)(.*) |
| 1 | 1 (nama default) | ((?<One>abc)\d+) |
| 2 | 2 (default nama) | (.*) |
| 3 | Satu | (?<One>abc) |
| 4 | Dua | (?<Two>xyz) |
Contoh berikut menggambarkan ekspresi reguler yang mengidentifikasi kata yang kembar dan kata yang langsung mengikuti setiap kata yang diduplikasi. Pola ekspresi reguler mendefinisikan dua subekspresi bernama: duplicateWord, yang mewakili kata duplikat, dan nextWord, yang mewakili kata yang mengikuti kata duplikat.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)";
string input = "He said that that was the the correct answer.";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
Console.WriteLine($"A duplicate '{match.Groups["duplicateWord"].Value}' at position {match.Groups["duplicateWord"].Index} is followed by '{match.Groups["nextWord"].Value}'.");
}
}
// The example displays the following output:
// A duplicate 'that' at position 8 is followed by 'was'.
// A duplicate 'the' at position 22 is followed by 'correct'.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)"
Dim input As String = "He said that that was the the correct answer."
Console.WriteLine(Regex.Matches(input, pattern, RegexOptions.IgnoreCase).Count)
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
Console.WriteLine("A duplicate '{0}' at position {1} is followed by '{2}'.", _
match.Groups("duplicateWord").Value, match.Groups("duplicateWord").Index, _
match.Groups("nextWord").Value)
Next
End Sub
End Module
' The example displays the following output:
' A duplicate 'that' at position 8 is followed by 'was'.
' A duplicate 'the' at position 22 is followed by 'correct'.
Pola regex adalah sebagai berikut:
(?<duplicateWord>\w+)\s\k<duplicateWord>\W(?<nextWord>\w+)
Tabel berikut menunjukkan bagaimana regex ditafsirkan.
| Pola | Deskripsi |
|---|---|
(?<duplicateWord>\w+) |
Mencocokkan satu atau beberapa karakter kata. Beri nama grup penangkap ini duplicateWord. |
\s |
Cocokkan karakter spasi kosong. |
\k<duplicateWord> |
Cocokkan string dari grup yang diambil yang diberi nama duplicateWord. |
\W |
Cocokkan karakter non-kata, termasuk spasi putih dan tanda baca. Ini mencegah pola ekspresi reguler dari mencocokkan kata yang dimulai dengan kata dari grup pertama yang menangkap. |
(?<nextWord>\w+) |
Mencocokkan satu atau beberapa karakter kata. Namai grup penangkap ini nextWord. |
Nama grup dapat diulang dalam ekspresi reguler. Misalnya, dimungkinkan bagi lebih dari satu grup untuk diberi nama digit, seperti yang diilustrasikan contoh berikut. Dalam kasus nama duplikat, nilai objek Group ditentukan oleh pengambilan terakhir yang berhasil dalam string input. Selain itu, CaptureCollection diisi dengan informasi tentang setiap tangkapan sama seperti jika nama grup tidak diduplikasi.
Dalam contoh berikut, regex\D+(?<digit>\d+)\D+(?<digit>\d+)? menyertakan dua kemunculan grup bernama digit. Grup bernama digit pertama menangkap satu atau beberapa karakter digit. Grup bernama digit kedua menangkap nol atau satu kemunculan dari satu atau lebih karakter digit. Seperti yang ditunjukkan oleh output dari contoh, jika grup penangkapan kedua berhasil mencocokkan teks, nilai teks tersebut menentukan nilai objek Group. Jika grup penangkapan kedua tidak cocok dengan string input, nilai kecocokan terakhir yang berhasil menentukan nilai Group objek.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
String pattern = @"\D+(?<digit>\d+)\D+(?<digit>\d+)?";
String[] inputs = { "abc123def456", "abc123def" };
foreach (var input in inputs) {
Match m = Regex.Match(input, pattern);
if (m.Success) {
Console.WriteLine($"Match: {m.Value}");
for (int grpCtr = 1; grpCtr < m.Groups.Count; grpCtr++) {
Group grp = m.Groups[grpCtr];
Console.WriteLine($"Group {grpCtr}: {grp.Value}");
for (int capCtr = 0; capCtr < grp.Captures.Count; capCtr++)
Console.WriteLine($" Capture {capCtr}: {grp.Captures[capCtr].Value}");
}
}
else {
Console.WriteLine("The match failed.");
}
Console.WriteLine();
}
}
}
// The example displays the following output:
// Match: abc123def456
// Group 1: 456
// Capture 0: 123
// Capture 1: 456
//
// Match: abc123def
// Group 1: 123
// Capture 0: 123
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\D+(?<digit>\d+)\D+(?<digit>\d+)?"
Dim inputs() As String = {"abc123def456", "abc123def"}
For Each input As String In inputs
Dim m As Match = Regex.Match(input, pattern)
If m.Success Then
Console.WriteLine("Match: {0}", m.Value)
For grpCtr As Integer = 1 to m.Groups.Count - 1
Dim grp As Group = m.Groups(grpCtr)
Console.WriteLine("Group {0}: {1}", grpCtr, grp.Value)
For capCtr As Integer = 0 To grp.Captures.Count - 1
Console.WriteLine(" Capture {0}: {1}", capCtr,
grp.Captures(capCtr).Value)
Next
Next
Else
Console.WriteLine("The match failed.")
End If
Console.WriteLine()
Next
End Sub
End Module
' The example displays the following output:
' Match: abc123def456
' Group 1: 456
' Capture 0: 123
' Capture 1: 456
'
' Match: abc123def
' Group 1: 123
' Capture 0: 123
Tabel berikut menunjukkan bagaimana regex ditafsirkan.
| Pola | Deskripsi |
|---|---|
\D+ |
Cocokkan satu atau beberapa karakter digit non-desimal. |
(?<digit>\d+) |
Cocokkan satu atau beberapa karakter digit desimal. Tetapkan pertandingan ke grup yang dinamai digit. |
\D+ |
Cocokkan satu atau beberapa karakter digit non-desimal. |
(?<digit>\d+)? |
Cocokkan nol atau satu kejadian dari satu atau beberapa karakter digit desimal. Tetapkan kecocokan ke grup bernama digit. |
Definisi kelompok penyeimbang
Definisi grup penyeimbangan menghapus definisi grup yang telah ditentukan sebelumnya dan menyimpan jarak antara grup yang sebelumnya dan grup saat ini dalam grup saat ini. Konstruksi pengelompokan ini berformat berikut:
(?<name1-name2>subexpression)
atau:
(?'name1-name2' subexpression)
Di sini, name1 adalah grup saat ini (opsional), name2 adalah grup yang ditentukan sebelumnya, dan subekspresi adalah pola ekspresi reguler yang valid. Definisi grup penyeimbangan menghapus definisi name2 dan menyimpan interval antara name2 dan name1 di name1. Jika tidak ada grup name2 yang ditentukan, pencocokan akan mundur. Karena menghapus definisi terakhir dari name2 mengungkapkan definisi sebelumnya dari name2, konstruksi ini memungkinkan Anda menggunakan tumpukan tangkapan untuk grup name2 sebagai penghitung untuk melacak konstruksi bersarang seperti tanda kurung buka-tutup atau tanda kurung lainnya.
Definisi grup penyeimbangan menggunakan name2 sebagai tumpukan. Karakter awal dari setiap struktur bersarang ditempatkan dalam grup dan dalam koleksi Group.Captures. Saat karakter penutup dicocokkan, karakter pembuka yang sesuai dihapus dari grup, dan koleksi Captures dikurangi sebanyak satu. Setelah karakter pembuka dan penutup dari semua konstruksi bersarang telah dicocokkan, name2 menjadi kosong.
Catatan
Setelah Anda memodifikasi ekspresi reguler dalam contoh berikut untuk menggunakan karakter pembukaan dan penutupan yang sesuai dari konstruksi bersarang, Anda dapat menggunakannya untuk menangani sebagian besar konstruksi bersarang, seperti ekspresi matematika atau baris kode program dengan beberapa panggilan metode bersarang di dalamnya.
Contoh berikut menggunakan definisi grup penyeimbangan untuk mencocokkan tanda kurung sudut kiri dan kanan (<>) dalam string input. Contoh berikut mendefinisikan dua grup bernama, Open dan Close, yang digunakan seperti tumpukan untuk melacak pasangan tanda kurung sudut yang cocok. Setiap tanda kurung sudut kiri yang ditangkap didorong ke dalam kumpulan tangkapan grup Open, dan setiap tanda kurung sudut kanan yang ditangkap didorong ke dalam kumpulan tangkapan grup Close. Definisi kelompok penyeimbang memastikan bahwa ada tanda kurung sudut kanan yang cocok untuk setiap tanda kurung sudut kiri. Jika tidak ada, subpola akhir, (?(Open)(?!)), dievaluasi hanya jika grup Open tidak kosong (dan, oleh karena itu, jika semua konstruksi bersarang belum ditutup). Jika subpola akhir dievaluasi, kecocokan gagal, karena subpola (?!) adalah pernyataan lookahead negatif lebar nol yang selalu gagal.
using System;
using System.Text.RegularExpressions;
class Example
{
public static void Main()
{
string pattern = "^[^<>]*" +
"(" +
"((?'Open'<)[^<>]*)+" +
"((?'Close-Open'>)[^<>]*)+" +
")*" +
"(?(Open)(?!))$";
string input = "<abc><mno<xyz>>";
Match m = Regex.Match(input, pattern);
if (m.Success == true)
{
Console.WriteLine($"Input: \"{input}\" \nMatch: \"{m}\"");
int grpCtr = 0;
foreach (Group grp in m.Groups)
{
Console.WriteLine($" Group {grpCtr}: {grp.Value}");
grpCtr++;
int capCtr = 0;
foreach (Capture cap in grp.Captures)
{
Console.WriteLine($" Capture {capCtr}: {cap.Value}");
capCtr++;
}
}
}
else
{
Console.WriteLine("Match failed.");
}
}
}
// The example displays the following output:
// Input: "<abc><mno<xyz>>"
// Match: "<abc><mno<xyz>>"
// Group 0: <abc><mno<xyz>>
// Capture 0: <abc><mno<xyz>>
// Group 1: <mno<xyz>>
// Capture 0: <abc>
// Capture 1: <mno<xyz>>
// Group 2: <xyz
// Capture 0: <abc
// Capture 1: <mno
// Capture 2: <xyz
// Group 3: >
// Capture 0: >
// Capture 1: >
// Capture 2: >
// Group 4:
// Group 5: mno<xyz>
// Capture 0: abc
// Capture 1: xyz
// Capture 2: mno<xyz>
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "^[^<>]*" & _
"(" + "((?'Open'<)[^<>]*)+" & _
"((?'Close-Open'>)[^<>]*)+" + ")*" & _
"(?(Open)(?!))$"
Dim input As String = "<abc><mno<xyz>>"
Dim rgx AS New Regex(pattern) '
Dim m As Match = Regex.Match(input, pattern)
If m.Success Then
Console.WriteLine("Input: ""{0}"" " & vbCrLf & "Match: ""{1}""", _
input, m)
Dim grpCtr As Integer = 0
For Each grp As Group In m.Groups
Console.WriteLine(" Group {0}: {1}", grpCtr, grp.Value)
grpCtr += 1
Dim capCtr As Integer = 0
For Each cap As Capture In grp.Captures
Console.WriteLine(" Capture {0}: {1}", capCtr, cap.Value)
capCtr += 1
Next
Next
Else
Console.WriteLine("Match failed.")
End If
End Sub
End Module
' The example displays the following output:
' Input: "<abc><mno<xyz>>"
' Match: "<abc><mno<xyz>>"
' Group 0: <abc><mno<xyz>>
' Capture 0: <abc><mno<xyz>>
' Group 1: <mno<xyz>>
' Capture 0: <abc>
' Capture 1: <mno<xyz>>
' Group 2: <xyz
' Capture 0: <abc
' Capture 1: <mno
' Capture 2: <xyz
' Group 3: >
' Capture 0: >
' Capture 1: >
' Capture 2: >
' Group 4:
' Group 5: mno<xyz>
' Capture 0: abc
' Capture 1: xyz
' Capture 2: mno<xyz>
Pola regex adalah:
^[^<>]*(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)*(?(Open)(?!))$
Ekspresi Reguler ditafsirkan sebagai berikut:
| Pola | Deskripsi |
|---|---|
^ |
Mulailah dari awal teks. |
[^<>]* |
Temukan nol atau lebih karakter yang bukan tanda kurung sudut kiri atau kanan. |
(?'Open'<) |
Cocokkan tanda kurung sudut kiri dan tetapkan ke grup bernama Open. |
[^<>]* |
Cocokkan nol atau lebih karakter yang bukan tanda kurung sudut kiri atau kanan. |
((?'Open'<)[^<>]*)+ |
Cocokkan satu atau lebih kemunculan tanda kurung sudut kiri yang diikuti oleh nol atau lebih karakter yang bukan tanda kurung sudut kiri atau kanan. Ini adalah kelompok penangkapan kedua. |
(?'Close-Open'>) |
Cocokkan tanda kurung sudut kanan, tetapkan substring antara grup Open dan grup saat ini ke grup Close, dan hapus definisi grup Open. |
[^<>]* |
Cocokkan nol atau lebih kejadian karakter apa pun yang bukan tanda kurung sudut kiri atau kanan. |
((?'Close-Open'>)[^<>]*)+ |
Cocokkan satu atau lebih kemunculan tanda kurung sudut kanan, diikuti dengan nol atau lebih kemunculan karakter apa pun yang bukan tanda kurung sudut kiri atau kanan. Saat mencocokkan tanda kurung sudut kanan, tetapkan substring antara grup Open dan grup saat ini ke grup Close, dan hapus definisi grup Open. Ini adalah grup pengambilan ketiga. |
(((?'Open'<)[^<>]*)+((?'Close-Open'>)[^<>]*)+)* |
Cocokkan nol atau lebih kejadian dari pola berikut: satu atau lebih kejadian tanda kurung sudut kiri, diikuti oleh nol atau lebih karakter tanda kurung non-sudut, diikuti oleh satu atau lebih kejadian tanda kurung sudut kanan, diikuti oleh nol atau lebih kejadian tanda kurung non-sudut. Saat mencocokkan tanda kurung sudut kanan, hapus definisi grup Open, dan tetapkan substring antara grup Open dan grup saat ini ke grup Close. Ini adalah grup penangkapan pertama. |
(?(Open)(?!)) |
Jika grup Open ada, abaikan kecocokan jika string kosong dapat cocok, tetapi jangan majukan posisi mesin regex dalam string. Ini adalah pernyataan lookahead negatif lebar nol. Karena string kosong selalu hadir secara implisit dalam string input, kecocokan ini selalu gagal. Kegagalan pencocokan ini menunjukkan bahwa tanda kurung sudut tidak seimbang. |
$ |
Cocokkan akhir string input. |
Subekspresi akhir, (?(Open)(?!)), mengindikasikan apakah konstruksi bertumpuk pada string masukan diseimbangkan dengan benar (misalnya, apakah setiap tanda kurung sudut kiri dicocokkan dengan tanda kurung sudut kanan). Ini menggunakan pencocokan kondisional berdasarkan grup yang diambil yang valid; untuk informasi selengkapnya, lihat Konstruksi Pergantian. Jika grup Open ditentukan, mesin regex mencoba mencocokkan subekspresi (?!) dalam string input. Grup Open harus didefinisikan hanya jika konstruksi bersarang tidak seimbang. Oleh karena itu, pola yang akan dicocokkan dalam string input harus menjadi salah satu yang selalu menyebabkan pencocokan gagal. Dalam hal ini, (?!) adalah pernyataan lookahead negatif lebar nol yang selalu gagal, karena string kosong selalu secara implisit ada pada posisi berikutnya dalam string input.
Dalam contoh, mesin regex mengevaluasi string input "<abc><mno<xyz>>" seperti yang ditunjukkan pada tabel berikut.
| Langkah | Pola | Hasil |
|---|---|---|
| 1 | ^ |
Memulai pencocokan di awal string input |
| 2 | [^<>]* |
Mencari karakter tanda kurung non-sudut sebelum tanda kurung sudut kiri;tidak menemukan kecocokan. |
| 3 | (((?'Open'<) |
Mencocokkan dengan tanda kurung sudut kiri di "<abc>" dan menetapkannya ke grup Open. |
| 4 | [^<>]* |
Mencocokkan dengan "abc". |
| 5 | )+ |
"<abc" adalah nilai dari grup kedua yang ditangkap. Karakter berikutnya dalam string input bukan tanda kurung sudut kiri, sehingga mesin regex tidak mengulang kembali ke subpola (?'Open'<)[^<>]*). |
| 6 | ((?'Close-Open'>) |
Mencocokkan dengan tanda kurung sudut kanan di "<abc>", menetapkan "abc", yang merupakan substring antara grup Open dan tanda kurung sudut kanan, ke grup Close, dan menghapus nilai saat ini ("<") dari grup Open, membiarkannya kosong. |
| 7 | [^<>]* |
Mencari karakter bukan tanda kurung sudut setelah tanda kurung sudut kanan; tidak menemukan kecocokan. |
| 8 | )+ |
Nilai grup ketiga yang ditangkap adalah ">". Karakter berikutnya dalam string input bukan tanda kurung sudut kanan, sehingga mesin regex tidak mengulang kembali ke subpola ((?'Close-Open'>)[^<>]*). |
| 9 | )* |
Nilai grup pertama yang ditangkap adalah "<abc>". Karakter berikutnya dalam string input adalah tanda kurung sudut kiri, sehingga mesin ekspresi reguler mengulangi subpola (((?'Open'<). |
| 10 | (((?'Open'<) |
Mencocokkan dengan tanda kurung sudut kiri di "<mno" dan menetapkannya ke grup Open. Koleksi Group.Captures sekarang memiliki nilai tunggal, "<". |
| 11 | [^<>]* |
Mencocokkan “mno”. |
| 12 | )+ |
"<mno" adalah nilai dari grup kedua yang diperoleh. Karakter berikutnya dalam string input adalah tanda kurung sudut kiri, sehingga mesin ekspresi reguler mengulang kembali ke subpola (?'Open'<)[^<>]*). |
| 13 | (((?'Open'<) |
Mencocokkan dengan tanda kurung sudut kiri di "<xyz>" dan menetapkannya ke grup Open. Koleksi Group.Captures dari grup Open sekarang mencakup dua tangkapan: tanda kurung sudut kiri dari "<mno", dan tanda kurung sudut kiri dari "<xyz>". |
| 14 | [^<>]* |
Mencocokkan "xyz". |
| 15 | )+ |
"<xyz" adalah nilai dari grup kedua yang ditangkap. Karakter berikutnya dalam string input bukan tanda kurung sudut kiri, sehingga mesin regex tidak mengulang kembali ke subpola (?'Open'<)[^<>]*). |
| 16 | ((?'Close-Open'>) |
Mencocokkan dengan tanda kurung sudut kanan di "<xyz>". "xyz", menetapkan substring antara grup Open dan tanda kurung sudut kanan ke grup Close, dan menghapus nilai grup Open saat ini. Nilai tangkapan sebelumnya (tanda kurung sudut kiri di "<mno") menjadi nilai grup Open saat ini. Koleksi Captures dari grup Open sekarang mencakup satu tangkapan, tanda kurung sudut kiri dari "<xyz>". |
| 17 | [^<>]* |
Mencari karakter selain tanda kurung sudut; tidak ditemukan kecocokan. |
| 18 | )+ |
Nilai grup ketiga yang ditangkap adalah ">". Karakter berikutnya dalam string input adalah tanda kurung sudut kanan, sehingga mesin ekspresi reguler mengulang kembali ke subpola ((?'Close-Open'>)[^<>]*). |
| 19 | ((?'Close-Open'>) |
Mencocokkan tanda kurung sudut kanan terakhir di "xyz>>", menugaskan "mno<xyz>" (substring antara grup Open dan tanda kurung sudut kanan) ke grup Close, dan menghapus nilai saat ini ke grup Open. Grup Open sekarang kosong. |
| 20 | [^<>]* |
Mencari karakter yang bukan tanda kurung sudut; tidak ada yang cocok ditemukan. |
| 21 | )+ |
Nilai grup ketiga yang ditangkap adalah ">". Karakter berikutnya dalam string input bukan tanda kurung sudut kanan, sehingga mesin regex tidak mengulang kembali ke subpola ((?'Close-Open'>)[^<>]*). |
| 22 | )* |
Nilai grup pertama yang ditangkap adalah "<mno<xyz>>". Karakter berikutnya dalam string input bukan tanda kurung sudut kiri, sehingga mesin regex tidak mengulang kembali ke subpola (((?'Open'<). |
| 23 | (?(Open)(?!)) |
Grup Open tidak ditentukan, sehingga tidak ada upaya pencocokan. |
| 24 | $ |
Mencocokkan akhir rangkaian masukan. |
Grup tanpa penangkapan
Konstruksi pengelompokan berikut tidak menangkap substring yang cocok dengan subekspresi:
(?:subexpression)
Di sini, subekspresi adalah pola ekspresi reguler yang valid. Konstruksi kelompok yang tidak menangkap biasanya digunakan ketika pembilang diterapkan pada suatu grup, tetapi substring yang ditangkap oleh grup tidak menarik.
Catatan
Jika ekspresi reguler menyertakan konstruksi pengelompokan bersarang, konstruksi kelompok luar yang tidak menangkap tidak berlaku untuk konstruksi grup bersarang bagian dalam.
Contoh berikut menggambarkan regex yang mencakup grup yang tidak menangkap. Perhatikan bahwa output tidak termasuk grup yang ditangkap.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(?:\b(?:\w+)\W*)+\.";
string input = "This is a short sentence.";
Match match = Regex.Match(input, pattern);
Console.WriteLine($"Match: {match.Value}");
for (int ctr = 1; ctr < match.Groups.Count; ctr++)
Console.WriteLine($" Group {ctr}: {match.Groups[ctr].Value}");
}
}
// The example displays the following output:
// Match: This is a short sentence.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(?:\b(?:\w+)\W*)+\."
Dim input As String = "This is a short sentence."
Dim match As Match = Regex.Match(input, pattern)
Console.WriteLine("Match: {0}", match.Value)
For ctr As Integer = 1 To match.Groups.Count - 1
Console.WriteLine(" Group {0}: {1}", ctr, match.Groups(ctr).Value)
Next
End Sub
End Module
' The example displays the following output:
' Match: This is a short sentence.
Regex (?:\b(?:\w+)\W*)+\. cocok dengan kalimat yang diakhiri dengan titik. Karena ekspresi reguler berfokus pada kalimat dan bukan pada kata-kata individu, konstruksi pengelompokan digunakan secara eksklusif sebagai kuantifikator. Pola regex ditafsirkan seperti yang ditunjukkan pada tabel berikut.
| Pola | Deskripsi |
|---|---|
\b |
Mulai pencocokan pada batas kata. |
(?:\w+) |
Mencocokkan satu atau beberapa karakter kata. Jangan masukkan teks yang cocok ke grup tangkapan. |
\W* |
Cocokkan nol atau lebih karakter yang bukan huruf atau angka. |
(?:\b(?:\w+)\W*)+ |
Cocokkan pola yang terdiri dari satu atau lebih karakter kata mulai dari batas kata, diikuti oleh nol atau lebih karakter non-kata, yang berulang satu kali atau lebih. Jangan tetapkan teks yang cocok ke grup yang diambil. |
\. |
Cocokkan tanda titik. |
Opsi Grup
Konstruksi pengelompokan berikut berlaku atau menonaktifkan opsi yang ditentukan dalam subekspresi:
(?imnsx-imnsx:
subekspresi)
Di sini, subekspresi adalah pola ekspresi reguler yang valid. Misalnya, (?i-s:) mengaktifkan ketidakpekaan huruf besar/kecil dan menonaktifkan mode baris tunggal. Untuk informasi selengkapnya tentang opsi sebaris yang bisa Anda tentukan, lihat Opsi Ekspresi Reguler.
Catatan
Anda dapat menentukan opsi yang berlaku untuk seluruh regex daripada subekspresi dengan menggunakan konstruktor kelas System.Text.RegularExpressions.Regex atau metode statik. Anda juga dapat menentukan opsi sebaris yang berlaku setelah titik tertentu dalam regex dengan menggunakan konstruksi bahasa (?imnsx-imnsx).
Konstruksi opsi grup tidak berfungsi sebagai grup penangkapan. Artinya, meskipun sebagian string yang ditangkap oleh subekspresi disertakan dalam proses pencocokan, sebagian tersebut tidak masuk dalam grup yang ditangkap dan tidak digunakan untuk mengisi objek GroupCollection.
Misalnya, ekspresi reguler \b(?ix: d \w+)\s dalam contoh berikut menggunakan opsi sebaris dalam konstruksi pengelompokan untuk mengaktifkan pencocokan yang tidak peka terhadap huruf besar/kecil dan mengabaikan spasi dalam pola dalam mengidentifikasi semua kata yang dimulai dengan huruf "d". Ekspresi reguler didefinisikan seperti yang ditunjukkan pada tabel berikut.
| Pola | Deskripsi |
|---|---|
\b |
Mulai pencocokan pada batas kata. |
(?ix: d \w+) |
Menggunakan pencocokan yang tidak peka huruf besar/kecil dan mengabaikan spasi dalam pola ini, mencocokkan "d" yang diikuti oleh satu atau beberapa karakter kata. |
\s |
Cocokkan karakter spasi kosong. |
string pattern = @"\b(?ix: d \w+)\s";
string input = "Dogs are decidedly good pets.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine($"'{match.Value}// found at index {match.Index}.");
// The example displays the following output:
// 'Dogs // found at index 0.
// 'decidedly // found at index 9.
Dim pattern As String = "\b(?ix: d \w+)\s"
Dim input As String = "Dogs are decidedly good pets."
For Each match As Match In Regex.Matches(input, pattern)
Console.WriteLine("'{0}' found at index {1}.", match.Value, match.Index)
Next
' The example displays the following output:
' 'Dogs ' found at index 0.
' 'decidedly ' found at index 9.
Pernyataan 'lookahead' positif dengan lebar nol
Konstruksi pengelompokan berikut mendefinisikan pernyataan lookahead positif lebar nol:
(?=
subekspresi)
Di sini, subekspresi adalah pola ekspresi reguler apa pun. Agar kecocokan berhasil, string input harus cocok dengan pola regex dalam subekspresi, meskipun substring yang cocok tidak disertakan dalam hasil pencocokan. Pernyataan lookahead positif dengan lebar nol tidak melakukan backtrack.
Biasanya, pernyataan pencarian maju positif dengan lebar nol ditemukan di akhir pola ekspresi reguler. Ini mendefinisikan substring yang harus ditemukan di akhir string agar kecocokan terjadi tetapi itu tidak boleh dimasukkan dalam kecocokannya. Hal ini juga berguna untuk mencegah backtracking yang berlebihan. Anda dapat menggunakan asersi lookahead positif dengan lebar nol untuk memastikan bahwa grup yang tertangkap tertentu dimulai dengan teks yang sesuai dengan bagian dari pola yang ditentukan untuk grup tersebut. Misalnya, jika grup penangkap cocok dengan karakter kata berturut-turut, Anda dapat menggunakan pernyataan lookahead positif lebar nol untuk mengharuskan karakter pertama menjadi karakter huruf besar alfabetik.
Contoh berikut menggunakan pernyataan lookahead positif lebar nol untuk mencocokkan kata yang mendahului kata kerja "adalah" dalam string input.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b\w+(?=\sis\b)";
string[] inputs = { "The dog is a Malamute.",
"The island has beautiful birds.",
"The pitch missed home plate.",
"Sunday is a weekend day." };
foreach (string input in inputs)
{
Match match = Regex.Match(input, pattern);
if (match.Success)
Console.WriteLine($"'{match.Value}' precedes 'is'.");
else
Console.WriteLine($"'{input}' does not match the pattern.");
}
}
}
// The example displays the following output:
// 'dog' precedes 'is'.
// 'The island has beautiful birds.' does not match the pattern.
// 'The pitch missed home plate.' does not match the pattern.
// 'Sunday' precedes 'is'.
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b\w+(?=\sis\b)"
Dim inputs() As String = {"The dog is a Malamute.", _
"The island has beautiful birds.", _
"The pitch missed home plate.", _
"Sunday is a weekend day."}
For Each input As String In inputs
Dim match As Match = Regex.Match(input, pattern)
If match.Success Then
Console.WriteLine("'{0}' precedes 'is'.", match.Value)
Else
Console.WriteLine("'{0}' does not match the pattern.", input)
End If
Next
End Sub
End Module
' The example displays the following output:
' 'dog' precedes 'is'.
' 'The island has beautiful birds.' does not match the pattern.
' 'The pitch missed home plate.' does not match the pattern.
' 'Sunday' precedes 'is'.
Regex \b\w+(?=\sis\b) ditafsirkan seperti yang diperlihatkan dalam tabel berikut.
| Pola | Deskripsi |
|---|---|
\b |
Mulai pencocokan pada batas awal kata |
\w+ |
Mencocokkan satu atau beberapa karakter kata. |
(?=\sis\b) |
Tentukan apakah karakter kata diikuti oleh karakter spasi dan string "is", yang berakhir pada akhir batas kata. Jika demikian, pertandingan berhasil dengan sukses. |
Pernyataan lookahead negatif tanpa lebar
Konstruksi pengelompokan berikut mendefinisikan pernyataan lookahead negatif lebar nol:
(?!
subekspresi)
Di sini, subekspresi adalah pola ekspresi reguler apa pun. Agar kecocokan berhasil, string input harus tidak cocok dengan pola regex dalam subekspresi, meskipun substring yang cocok tidak disertakan dalam hasil pencocokan.
Pernyataan "lookahead" negatif dengan lebar nol biasanya digunakan di awal atau akhir ekspresi reguler (regex). Pada awal ekspresi reguler, pola tertentu dapat ditentukan agar tidak dicocokkan ketika awal ekspresi reguler tersebut mendefinisikan pola yang serupa tetapi lebih umum untuk dicocokkan. Dalam kasus ini, cara ini sering digunakan untuk membatasi backtracking. Pada akhir sebuah ekspresi reguler, dapat ditentukan subekspresi yang tidak dapat terjadi di akhir dari sebuah pencocokan.
Contoh berikut mendefinisikan ekspresi reguler yang menggunakan pernyataan lookahead tanpa lebar di awal ekspresi reguler untuk mencocokkan kata-kata yang tidak dimulai dengan "un".
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b(?!un)\w+\b";
string input = "unite one unethical ethics use untie ultimate";
foreach (Match match in Regex.Matches(input, pattern, RegexOptions.IgnoreCase))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// one
// ethics
// use
// ultimate
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b(?!un)\w+\b"
Dim input As String = "unite one unethical ethics use untie ultimate"
For Each match As Match In Regex.Matches(input, pattern, RegexOptions.IgnoreCase)
Console.WriteLine(match.Value)
Next
End Sub
End Module
' The example displays the following output:
' one
' ethics
' use
' ultimate
Regex \b(?!un)\w+\b ditafsirkan seperti yang diperlihatkan dalam tabel berikut.
| Pola | Deskripsi |
|---|---|
\b |
Mulailah pencocokan di batas awal kata. |
(?!un) |
Tentukan apakah dua karakter berikutnya adalah "un". Jika kondisi sebelumnya tidak terpenuhi, kecocokan mungkin terjadi. |
\w+ |
Mencocokkan satu atau beberapa karakter kata. |
\b |
Mengakhiri pertandingan pada batas kata. |
Contoh berikut mendefinisikan sebuah ekspresi reguler yang menggunakan asersi lookahead lebar nol di akhir ekspresi reguler untuk mencocokkan kata-kata yang tidak diakhiri karakter tanda baca.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"\b\w+\b(?!\p{P})";
string input = "Disconnected, disjointed thoughts in a sentence fragment.";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// disjointed
// thoughts
// in
// a
// sentence
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "\b\w+\b(?!\p{P})"
Dim input As String = "Disconnected, disjointed thoughts in a sentence fragment."
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:
' disjointed
' thoughts
' in
' a
' sentence
Regex \b\w+\b(?!\p{P}) ditafsirkan seperti yang diperlihatkan dalam tabel berikut.
| Pola | Deskripsi |
|---|---|
\b |
Mulai pencocokan pada batas awal kata. |
\w+ |
Mencocokkan satu atau beberapa karakter kata. |
\b |
Mengakhiri pencocokan dalam batas kata. |
\p{P}) |
Jika karakter berikutnya bukan simbol tanda baca (seperti titik atau koma), pencocokan berhasil. |
Pernyataan pencarian belakang positif lebar-nol
Konstruksi pengelompokan berikut mendefinisikan pernyataan lookbehind positif lebar nol:
(?<=
subekspresi)
Di sini, subekspresi adalah pola ekspresi reguler apa pun. Agar kecocokan berhasil, subekspresi harus terjadi pada string input di sebelah kiri posisi saat ini, meskipun subexpression tidak disertakan dalam hasil pencocokan. Pernyataan positive lookbehind dengan lebar nol tidak melakukan backtrack.
Pernyataan lookbehind positif lebar nol biasanya digunakan pada awal regex. Pola yang mereka definisikan adalah prasyarat untuk pencocokan, meskipun itu bukan bagian dari hasil pencocokan.
Misalnya, contoh berikut mencocokkan dua digit terakhir dari tahun untuk abad kedua puluh satu (yaitu, mengharuskan digit "20" berada di depan string yang dicocokkan).
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string input = "2010 1999 1861 2140 2009";
string pattern = @"(?<=\b20)\d{2}\b";
foreach (Match match in Regex.Matches(input, pattern))
Console.WriteLine(match.Value);
}
}
// The example displays the following output:
// 10
// 09
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim input As String = "2010 1999 1861 2140 2009"
Dim pattern As String = "(?<=\b20)\d{2}\b"
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:
' 10
' 09
Pola regex (?<=\b20)\d{2}\b ditafsirkan seperti yang ditunjukkan pada tabel berikut.
| Pola | Deskripsi |
|---|---|
\d{2} |
Cocokkan dua digit desimal. |
(?<=\b20) |
Lanjutkan pencocokan jika dua digit desimal didahului oleh digit desimal "20" pada batas kata. |
\b |
Mengakhiri pertandingan di batas kata. |
Pernyataan lookbehind positif lebar nol juga digunakan untuk membatasi backtracking ketika karakter atau karakter terakhir dalam grup yang ditangkap harus merupakan subset dari karakter yang cocok dengan pola regex grup tersebut. Misalnya, jika grup menangkap semua karakter kata berturut-turut, Anda dapat menggunakan pernyataan lookbehind positif lebar nol untuk mengharuskan karakter terakhir menjadi alfabetik.
Pernyataan lookbehind negatif tanpa lebar
Konstruksi pengelompokan berikut mendefinisikan pernyataan negative lookbehind dengan lebar nol:
(?<!
subekspresi)
Di sini, subekspresi adalah pola ekspresi reguler apa pun. Agar kecocokan berhasil, subekspresi tidak boleh terjadi pada string input di sebelah kiri posisi saat ini. Namun, substring apa pun yang tidak cocok dengan subexpression tidak disertakan dalam hasil pencocokan.
Pernyataan lookbehind negatif lebar nol biasanya digunakan pada awal regex. Pola yang mereka definisikan menghalangi kecocokan dalam string berikutnya. Mereka juga digunakan untuk membatasi backtracking ketika karakter atau karakter terakhir dalam grup yang ditangkap tidak boleh merupakan satu atau lebih karakter yang cocok dengan pola regex grup itu. Misalnya, jika grup menangkap semua karakter kata berturut-turut, Anda dapat menggunakan aserti lookbehind positif dengan lebar nol untuk mengharuskan karakter terakhir bukan garis bawah (_).
Contoh berikut cocok dengan tanggal untuk setiap hari dalam seminggu yang bukan akhir pekan (yaitu, itu bukan Sabtu atau Minggu).
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] dates = { "Monday February 1, 2010",
"Wednesday February 3, 2010",
"Saturday February 6, 2010",
"Sunday February 7, 2010",
"Monday, February 8, 2010" };
string pattern = @"(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b";
foreach (string dateValue in dates)
{
Match match = Regex.Match(dateValue, pattern);
if (match.Success)
Console.WriteLine(match.Value);
}
}
}
// The example displays the following output:
// February 1, 2010
// February 3, 2010
// February 8, 2010
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim dates() As String = {"Monday February 1, 2010", _
"Wednesday February 3, 2010", _
"Saturday February 6, 2010", _
"Sunday February 7, 2010", _
"Monday, February 8, 2010"}
Dim pattern As String = "(?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b"
For Each dateValue As String In dates
Dim match As Match = Regex.Match(dateValue, pattern)
If match.Success Then
Console.WriteLine(match.Value)
End If
Next
End Sub
End Module
' The example displays the following output:
' February 1, 2010
' February 3, 2010
' February 8, 2010
Pola regex (?<!(Saturday|Sunday) )\b\w+ \d{1,2}, \d{4}\b ditafsirkan seperti yang ditunjukkan pada tabel berikut.
| Pola | Deskripsi |
|---|---|
\b |
Memulai pencocokan dalam batas kata. |
\w+ |
Cocokkan satu atau beberapa karakter huruf yang diikuti oleh karakter spasi. |
\d{1,2}, |
Cocokkan satu atau dua digit desimal yang diikuti dengan karakter spasi dan koma. |
\d{4}\b |
Cocokkan empat digit desimal, dan akhiri kecocokan pada batas kata. |
(?<!(Saturday|Sunday) ) |
Jika kecocokan didahului oleh sesuatu selain string "Sabtu" atau "Minggu" diikuti oleh spasi, kecocokan berhasil. |
Kelompok atom
Konstruksi pengelompokan berikut mewakili grup atom (dikenal di beberapa mesin regex lainnya sebagai subekspresi nonbacktracking, subekspresi atom, atau subekspresi sekali saja):
(?>
subekspresi)
Di sini, subekspresi adalah pola ekspresi reguler apa pun.
Biasanya, jika regex menyertakan pola pencocokan opsional atau alternatif dan kecocokan tidak berhasil, mesin regex dapat bercabang ke berbagai arah untuk mencocokkan string input dengan pola. Jika kecocokan tidak ditemukan saat mengambil cabang pertama, mesin ekspresi reguler dapat kembali atau mundur ke titik di mana kecocokan pertama ditemukan dan mencoba menemukan kecocokan dengan cabang kedua. Proses ini dapat berlanjut hingga semua cabang telah dicoba.
Konstruksi bahasa (?>subekspresi) menonaktifkan pencarian ulang. Mesin ekspresi reguler akan mencocokkan sebanyak mungkin karakter dalam string input. Ketika tidak ada lagi kemungkinan pencocokan, algoritma tidak akan mundur untuk mencoba pencocokan pola alternatif. (Artinya, subekspresi hanya cocok dengan string yang akan dicocokkan dengan subekspresi saja; tidak berusaha mencocokkan string berdasarkan subekspresi dan subekspresi apa pun yang mengikutinya.)
Opsi ini disarankan jika Anda mengetahui bahwa backtracking tidak akan berhasil. Mencegah mesin ekspresi reguler melakukan pencarian yang tidak perlu dapat meningkatkan performa.
Contoh berikut menggambarkan bagaimana grup atom memodifikasi hasil kecocokan pola. Ekspresi reguler backtracking berhasil mencocokkan serangkaian karakter yang diulang diikuti oleh satu kali lagi kemunculan karakter yang sama pada batas kata, tetapi ekspresi reguler nonbacktracking tidak.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string[] inputs = { "cccd.", "aaad", "aaaa" };
string back = @"(\w)\1+.\b";
string noback = @"(?>(\w)\1+).\b";
foreach (string input in inputs)
{
Match match1 = Regex.Match(input, back);
Match match2 = Regex.Match(input, noback);
Console.WriteLine($"{input}: ");
Console.Write(" Backtracking : ");
if (match1.Success)
Console.WriteLine(match1.Value);
else
Console.WriteLine("No match");
Console.Write(" Nonbacktracking: ");
if (match2.Success)
Console.WriteLine(match2.Value);
else
Console.WriteLine("No match");
}
}
}
// The example displays the following output:
// cccd.:
// Backtracking : cccd
// Nonbacktracking: cccd
// aaad:
// Backtracking : aaad
// Nonbacktracking: aaad
// aaaa:
// Backtracking : aaaa
// Nonbacktracking: No match
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim inputs() As String = {"cccd.", "aaad", "aaaa"}
Dim back As String = "(\w)\1+.\b"
Dim noback As String = "(?>(\w)\1+).\b"
For Each input As String In inputs
Dim match1 As Match = Regex.Match(input, back)
Dim match2 As Match = Regex.Match(input, noback)
Console.WriteLine("{0}: ", input)
Console.Write(" Backtracking : ")
If match1.Success Then
Console.WriteLine(match1.Value)
Else
Console.WriteLine("No match")
End If
Console.Write(" Nonbacktracking: ")
If match2.Success Then
Console.WriteLine(match2.Value)
Else
Console.WriteLine("No match")
End If
Next
End Sub
End Module
' The example displays the following output:
' cccd.:
' Backtracking : cccd
' Nonbacktracking: cccd
' aaad:
' Backtracking : aaad
' Nonbacktracking: aaad
' aaaa:
' Backtracking : aaaa
' Nonbacktracking: No match
Regex nonbacktracking (?>(\w)\1+).\b didefinisikan seperti yang ditunjukkan pada tabel berikut ini.
| Pola | Deskripsi |
|---|---|
(\w) |
Cocokkan satu karakter kata dan tetapkan ke grup penangkap pertama. |
\1+ |
Cocokkan nilai substring pertama yang ditangkap satu kali atau lebih. |
. |
Cocokkan karakter apa pun. |
\b |
Akhiri pencocokan pada batas kata. |
(?>(\w)\1+) |
Cocokkan satu atau beberapa kemunculan karakter kata duplikat, tetapi jangan mundur untuk mencocokkan karakter terakhir pada batas kata. |
Konstruksi pengelompokan dan objek ekspresi reguler
Substring yang dicocokkan dengan grup pengambilan ekspresi reguler diwakili oleh objek System.Text.RegularExpressions.Group, yang dapat diperoleh dari objek System.Text.RegularExpressions.GroupCollection yang dikembalikan oleh properti Match.Groups. Objek GroupCollection diisi sebagai berikut:
- Objek Group pertama dalam koleksi (objek pada indeks nol) mewakili seluruh kecocokan.
- Kumpulan objek berikutnya Group mewakili grup tangkapan yang tidak bernama (bernomor). Mereka muncul dalam urutan di mana mereka didefinisikan dalam regex, dari kiri ke kanan. Nilai indeks dari grup-grup ini berkisar dari 1 hingga jumlah grup penangkap yang tidak bernama dalam koleksi. (Indeks grup tertentu setara dengan backreference bernomornya. Untuk informasi selengkapnya tentang backreference, lihat Konstruksi Backreference.)
- Set objek Group akhir mewakili grup penangkap bernama. Mereka muncul dalam urutan di mana mereka didefinisikan dalam regex, dari kiri ke kanan. Nilai indeks dari grup penangkap bernama pertama adalah satu lebih besar dari indeks grup penangkap terakhir yang tidak bernama. Jika tidak ada kelompok penangkap yang tidak bernama dalam ekspresi reguler, nilai indeks dari grup penangkap yang bernama pertama adalah satu.
Jika Anda menerapkan pembilang ke grup penangkapan, properti objek Group, Capture.Value, Capture.Index,dan Capture.Length yang sesuai mencerminkan substring terakhir yang ditangkap oleh grup penangkapan. Anda dapat mengambil sekumpulan substring lengkap yang ditangkap oleh grup yang memiliki pembilang dari objek CaptureCollection yang dikembalikan oleh properti Group.Captures.
Contoh berikut mengklarifikasi hubungan antara objek Group dan Capture.
using System;
using System.Text.RegularExpressions;
public class Example
{
public static void Main()
{
string pattern = @"(\b(\w+)\W+)+";
string input = "This is a short sentence.";
Match match = Regex.Match(input, pattern);
Console.WriteLine($"Match: '{match.Value}'");
for (int ctr = 1; ctr < match.Groups.Count; ctr++)
{
Console.WriteLine($" Group {ctr}: '{match.Groups[ctr].Value}'");
int capCtr = 0;
foreach (Capture capture in match.Groups[ctr].Captures)
{
Console.WriteLine($" Capture {capCtr}: '{capture.Value}'");
capCtr++;
}
}
}
}
// The example displays the following output:
// Match: 'This is a short sentence.'
// Group 1: 'sentence.'
// Capture 0: 'This '
// Capture 1: 'is '
// Capture 2: 'a '
// Capture 3: 'short '
// Capture 4: 'sentence.'
// Group 2: 'sentence'
// Capture 0: 'This'
// Capture 1: 'is'
// Capture 2: 'a'
// Capture 3: 'short'
// Capture 4: 'sentence'
Imports System.Text.RegularExpressions
Module Example
Public Sub Main()
Dim pattern As String = "(\b(\w+)\W+)+"
Dim input As String = "This is a short sentence."
Dim match As Match = Regex.Match(input, pattern)
Console.WriteLine("Match: '{0}'", match.Value)
For ctr As Integer = 1 To match.Groups.Count - 1
Console.WriteLine(" Group {0}: '{1}'", ctr, match.Groups(ctr).Value)
Dim capCtr As Integer = 0
For Each capture As Capture In match.Groups(ctr).Captures
Console.WriteLine(" Capture {0}: '{1}'", capCtr, capture.Value)
capCtr += 1
Next
Next
End Sub
End Module
' The example displays the following output:
' Match: 'This is a short sentence.'
' Group 1: 'sentence.'
' Capture 0: 'This '
' Capture 1: 'is '
' Capture 2: 'a '
' Capture 3: 'short '
' Capture 4: 'sentence.'
' Group 2: 'sentence'
' Capture 0: 'This'
' Capture 1: 'is'
' Capture 2: 'a'
' Capture 3: 'short'
' Capture 4: 'sentence'
Pola ekspresi reguler (\b(\w+)\W+)+ mengekstrak kata individual dari string. Ini didefinisikan seperti yang ditunjukkan pada tabel berikut.
| Pola | Deskripsi |
|---|---|
\b |
Memulai pencocokan pada batas kata. |
(\w+) |
Mencocokkan satu atau beberapa karakter kata. Bersama-sama, karakter-karakter ini membentuk sebuah kata. Ini adalah grup penangkapan kedua. |
\W+ |
Cocokkan satu atau beberapa karakter non-kata. |
(\b(\w+)\W+) |
Cocokkan pola satu atau beberapa karakter kata yang diikuti oleh satu atau lebih karakter non-kata berulang kali. Ini adalah kelompok penangkapan pertama. |
Kelompok penangkap kedua cocok dengan setiap kata dalam kalimat. Kelompok penangkap pertama menangkap setiap kata bersama dengan tanda baca dan spasi putih yang mengikuti kata tersebut. Objek Group yang indeksnya adalah 2 menyediakan informasi tentang teks yang cocok dengan grup pengambilan kedua. Seluruh kumpulan kata yang diambil oleh kelompok penangkapan tersedia dari objek CaptureCollection yang dikembalikan oleh properti Group.Captures.
Lihat juga
Berkolaborasi dengan kami di GitHub
Sumber untuk konten ini dapat ditemukan di GitHub, yang juga dapat Anda gunakan untuk membuat dan meninjau masalah dan menarik permintaan. Untuk informasi selengkapnya, lihat panduan kontributor kami.
