RegEx: 20 langkah singkat untuk menguasai ekspresi reguler. Bagian 4

RegEx: 20 langkah singkat untuk menguasai ekspresi reguler. Bagian 1 RegEx: 20 langkah singkat untuk menguasai ekspresi reguler. Bagian 2 20 langkah singkat untuk menguasai ekspresi reguler. Bagian 3 Bagian terakhir ini, di tengah, akan membahas hal-hal yang terutama digunakan oleh master ekspresi reguler. Tapi materi dari bagian sebelumnya mudah bagi Anda bukan? Ini berarti Anda dapat menangani materi ini dengan mudah! Asli di sini <h2>Langkah 16: mengelompokkan tanpa menangkap (?:)</h2> Dalam dua contoh di langkah sebelumnya, kita menangkap teks yang sebenarnya tidak kita perlukan. Dalam tugas Ukuran File, kami mengambil spasi sebelum digit pertama ukuran file, dan dalam tugas CSV, kami mengambil koma di antara setiap token. Kita tidak perlu menangkap karakter ini, tapi kita perlu menggunakannya untuk menyusun ekspresi reguler kita. Ini adalah pilihan ideal untuk menggunakan grup tanpa menangkap, (?:). Grup yang tidak menangkap melakukan persis seperti yang terlihat - memungkinkan karakter untuk dikelompokkan dan digunakan dalam ekspresi reguler, tetapi tidak menangkapnya dalam grup bernomor:

pola: (?:")([^"]+)(?:") 
string: Saya hanya ingin "teks di dalam tanda kutip ini" .
pertandingan:             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
grup:                 111111111111111111111111111    

( Contoh ) Ekspresi reguler sekarang cocok dengan teks yang dikutip serta karakter kutipan itu sendiri, namun grup penangkap hanya menangkap teks yang dikutip. Mengapa kita harus melakukan ini? Intinya adalah sebagian besar mesin ekspresi reguler memungkinkan Anda memulihkan teks dari grup pengambilan yang ditentukan dalam ekspresi reguler Anda. Jika kita dapat memangkas karakter tambahan yang tidak kita perlukan tanpa memasukkannya ke dalam grup pengambilan, hal ini akan mempermudah penguraian dan manipulasi teks nantinya. Berikut cara membersihkan parser CSV dari langkah sebelumnya:

pola: (?:^|,)\s*(?:\"([^",]*)\"|([^", ]*)) 
string:   a , " b ", " cd ", e , f , " gh ", dfgi ,, k , "", l 
cocok: ^ ^ ^^^ ^ ^ ^^^ ^^^^ ^ ^ 
grup:    2 1 111 2 2 111 2222 2 2    

( Contoh ) Ada beberapa hal yang <mark>perhatikan di sini:</mark> Pertama, kita tidak lagi menggunakan koma sejak kita mengubah grup penangkap (^|,)menjadi grup yang tidak menangkap (?:^|,). Kedua, kami menyarangkan grup penangkap ke dalam grup non-penangkap. Ini berguna ketika, misalnya, Anda memerlukan sekelompok karakter untuk muncul dalam urutan tertentu, namun Anda hanya peduli pada subkumpulan karakter tersebut. Dalam kasus kami, kami memerlukan karakter non- kutipan dan non- koma [^",]*untuk muncul dalam tanda kutip, namun kami sebenarnya tidak memerlukan karakter kutipan itu sendiri, sehingga tidak perlu ditangkap. Terakhir, <mark>perhatikan</mark> bahwa pada contoh di atas juga terdapat kecocokan panjang nol antara karakter kdan l. Tanda kutip ""adalah substring yang dicari, tetapi tidak ada karakter di antara tanda kutip, sehingga substring yang cocok tidak berisi karakter (panjang nol). <h3>Haruskah kita mengkonsolidasikan pengetahuan kita? Berikut adalah dua setengah tugas yang akan membantu kita dalam hal ini:</h3> Menggunakan grup yang tidak menangkap (dan grup menangkap, dan kelas karakter, dll.), tulis ekspresi reguler yang hanya menangkap ukuran file yang diformat dengan benar di baris di bawah :

pola:
string:   6.6KB 1..3KB 12KB 5G 3.3MB KB .6.2TB 9MB .
pertandingan: ^^^^^ ^^^^^ ^^^^^^ ^^^^ 
grup:    11111 1111 11111 111    

( Solusi ) Tag pembuka HTML dimulai dengan <dan diakhiri dengan >. Tag penutup HTML diawali dengan rangkaian karakter </dan diakhiri dengan karakter >. Nama tag terdapat di antara karakter-karakter ini. Bisakah Anda menulis ekspresi reguler untuk hanya menangkap nama di tag berikut? (Anda mungkin dapat memecahkan masalah ini tanpa menggunakan kelompok yang tidak menangkap. Coba selesaikan dengan dua cara! Sekali dengan kelompok dan sekali tanpa kelompok.)

pola:
string:   <p> </span> <div> </kbd> <link> 
cocok: ^^^ ^^^^^^ ^^^^^ ^^^^^^ ^^^^^^ 
grup:    1 1111 111 111 1111    

( Solusi menggunakan grup yang tidak menangkap ) ( Solusi tanpa menggunakan grup yang tidak menangkap ) <h2>Langkah 17: Tautan balik \Ndan memberi nama grup penangkap</h2> Meskipun saya sudah memperingatkan Anda di pendahuluan bahwa mencoba membuat parser HTML menggunakan ekspresi reguler biasanya menyebabkan sakit hati, contoh terakhir ini adalah bagian yang bagus ke fitur lain (terkadang) berguna dari sebagian besar ekspresi reguler: referensi balik. Tautan balik seperti grup berulang tempat Anda dapat mencoba menangkap teks yang sama dua kali. Namun keduanya berbeda dalam satu aspek penting - mereka hanya akan menangkap teks yang sama, karakter demi karakter. Sementara grup yang berulang akan memungkinkan kita menangkap sesuatu seperti ini:

pola: (dia(?:[az])+) 
string:   heyabcdefg hei heyo hekuning heyyyyyyyyy 
cocok: ^^^^^^^^^ ^^^ ^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ 
grup:    1111111111 111 1111 11111111 11111111111    

( Contoh ) ...maka backlink yang akan cocok hanya ini:

pola: (he([az])(\2+)) 
string: heyabcdefg hei heyo hekuning heyyyyyyyyy 
cocok:                              ^^^^^^^^^^^ 
grup:                                 11233333333    

( Contoh ) Grup pengambilan berulang berguna bila Anda ingin mencocokkan pola yang sama berulang kali, sedangkan tautan balik bagus bila Anda ingin mencocokkan teks yang sama. Misalnya, kita dapat menggunakan tautan balik untuk mencoba menemukan tag HTML pembuka dan penutup yang cocok:

pola: <(\w+)[^>]*>[^<]+<\/\1> 
string:   <span style="color: red">hei</span> 
cocok: ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^ 
grup:    1111    

( Contoh ) <mark>Harap dicatat</mark> bahwa ini adalah contoh yang sangat disederhanakan dan saya sangat menyarankan agar Anda tidak mencoba menulis parser HTML berbasis ekspresi reguler. Ini adalah sintaksis yang sangat rumit dan kemungkinan besar akan membuat Anda sakit. Grup penangkap bernama sangat mirip dengan tautan balik, jadi saya akan membahasnya secara singkat di sini. Satu-satunya perbedaan antara referensi balik dan grup tangkapan bernama adalah... grup tangkapan bernama memiliki nama:

pola: <(?<tag>\w+)[^>]*>[^<]+<\/(?P=tag)></tag> 
string:   <span style="color: red">hai< /span> 
cocok: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
grup:    1111    

( Contoh ) Anda dapat membuat grup penangkap bernama menggunakan sintaksis (?<nama>...) atau (?'nama'...) (ekspresi reguler yang kompatibel dengan .NET) atau dengan sintaksis ini (?P<nama>. ..) atau (?P'name'...) (ekspresi reguler yang kompatibel dengan Python). Karena kami menggunakan PCRE (Ekspresi Reguler Kompatibel Perl) yang mendukung kedua versi, kami dapat menggunakan salah satunya di sini. (Java 7 menyalin sintaks .NET, tetapi hanya versi tanda kurung sudut. Catatan Penerjemah) Untuk mengulangi grup penangkap bernama nanti dalam ekspresi reguler, kami menggunakan \<kname> atau \k'name' (.NET) atau (? P= nama) (Python). Sekali lagi, PCRE mendukung semua opsi berbeda ini. Anda dapat membaca lebih lanjut tentang grup penangkap bernama di sini , namun inilah sebagian besar hal yang benar-benar perlu Anda ketahui tentang grup tersebut. <h3>Tugas untuk membantu kami:</h3> Gunakan backlink untuk membantu saya mengingat... ummm... nama orang ini.

pola:
string: "Hai, nama saya Joe." [nanti] "Siapa nama orang itu? Joe ?"
pertandingan:        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
grup:                  111    

( Solusi ) <h2>Langkah 18: melihat ke depan dan ke belakang</h2> Sekarang kita akan mendalami beberapa fitur lanjutan dari ekspresi reguler. Saya cukup sering menggunakan semuanya hingga langkah 16. Namun beberapa langkah terakhir ini hanya untuk orang yang menggunakan regex dengan sangat serius untuk mencocokkan ekspresi yang sangat kompleks. Dengan kata lain, ahli ekspresi reguler. "Melihat ke Depan" dan "Melihat ke Belakang" mungkin tampak cukup rumit, namun sebenarnya tidak terlalu rumit. Mereka memungkinkan Anda melakukan sesuatu yang mirip dengan apa yang kami lakukan dengan grup yang tidak menangkap sebelumnya - periksa apakah ada teks tepat sebelum atau segera setelah teks sebenarnya yang ingin kami cocokkan. Misalnya, kita hanya ingin mencocokkan nama benda yang disukai orang saja, namun hanya jika orang tersebut antusias (hanya jika orang tersebut mengakhiri kalimatnya dengan tanda seru). Kita bisa melakukan sesuatu seperti:

pola: (\w+)(?=!) 
string: Saya suka meja. Saya menghargai stapler. Saya suka lampu !
pertandingan:                                           ^^^^ 
grup:                                              1111    

( Contoh ) Anda dapat melihat bagaimana grup tangkapan di atas (\w+), yang biasanya cocok dengan salah satu kata dalam bagian tersebut, hanya cocok dengan kata lamp. Pandangan ke depan yang positif (?=!)berarti kita hanya dapat mencocokkan urutan yang diakhiri dengan !tetapi kita tidak benar-benar mencocokkan karakter tanda seru itu sendiri. Ini merupakan perbedaan yang penting karena dengan kelompok yang tidak menangkap, kita mencocokkan karakternya tetapi tidak menangkapnya. Dengan melihat ke depan dan ke belakang, kita menggunakan karakter untuk membangun ekspresi reguler, namun kita bahkan tidak mencocokkannya dengan karakter itu sendiri. Kita bisa mencocokkannya nanti di ekspresi reguler kita. Ada empat jenis pandangan ke depan dan ke belakang: pandangan ke depan positif (?=...), pandangan ke depan negatif (?!...), pandangan ke depan positif (?<=...) dan pandangan ke depan negatif (?<!. ..) . Mereka melakukan apa yang terdengar seperti - pandangan ke depan dan ke belakang yang positif memungkinkan mesin ekspresi reguler untuk terus mencocokkan hanya ketika teks yang terdapat dalam tampilan ke depan/lihat ke belakang benar-benar cocok. Pandangan ke depan dan ke belakang yang negatif melakukan hal yang sebaliknya - keduanya memperbolehkan regex untuk cocok hanya jika teks yang terdapat dalam tampilan ke depan/lihat ke belakang tidak cocok. Misalnya, kita ingin mencocokkan nama metode hanya dalam rangkaian urutan metode, bukan objek tempat metode tersebut dioperasikan. Dalam hal ini, setiap nama metode harus diawali dengan tanda .. Ekspresi reguler yang menggunakan lihat ke belakang sederhana dapat membantu di sini:

pola: (?<=\.)(\w+) 
string: myArray. flatMap.aggregate.summarise.print !
pertandingan:         ^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^ 
grup:            1111111 111111111 111111111 11111    

( Contoh ) Dalam teks di atas, kita mencocokkan rangkaian karakter kata apa pun \w+, tetapi hanya jika karakter tersebut didahului oleh karakter tersebut .. Kita dapat mencapai hal serupa dengan menggunakan grup non-penangkap, namun hasilnya sedikit lebih berantakan:

pola: (?:\.)(\w+) 
string: myArray .flatMap.aggregate.summarise.print !
pertandingan:        ^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^ 
grup:            1111111 111111111 111111111 11111    

( Contoh ) Walaupun lebih pendek, tapi cocok dengan karakter yang tidak kita perlukan. Meskipun contoh ini mungkin tampak sepele, melihat ke depan dan ke belakang benar-benar dapat membantu kita membersihkan ekspresi reguler kita. <h3>Hanya sedikit yang tersisa sampai garis finish! 2 tugas berikut akan membawa kita 1 langkah lebih dekat ke sana:</h3> Tampilan belakang negatif (?<!...) memungkinkan mesin ekspresi reguler untuk terus mencoba menemukan kecocokan hanya jika teks yang terdapat di dalam tampilan belakang negatif tidak ditampilkan hingga sisa teks, yang dengannya Anda perlu menemukan kecocokan. Misalnya, kita dapat menggunakan ekspresi reguler untuk mencocokkan hanya nama belakang perempuan yang menghadiri konferensi. Untuk melakukan hal ini, kami ingin memastikan bahwa nama belakang orang tersebut tidak diawali dengan Mr.. Bisakah Anda menulis ekspresi reguler untuk ini? (Nama belakang dapat diasumsikan memiliki panjang minimal empat karakter.)

pola:
rangkaian: Bpk. Coklat, Ny. Smith , Ny. Jones , Nona Daisy , Tuan. Hijau
pertandingan:                ^^^^^ ^^^^^ ^^^^^ 
grup:                   11111 11111 11111    

( Solusi ) Katakanlah kita sedang membersihkan database dan kita memiliki kolom informasi yang mewakili persentase. Sayangnya, ada orang yang menulis angka sebagai nilai desimal dalam kisaran [0,0, 1,0], sementara yang lain menulis persentase dalam kisaran [0,0%, 100,0%], dan masih ada lagi yang menulis nilai persentase, tetapi lupa tanda persen literal %. Dengan menggunakan pandangan ke depan negatif (?!...), dapatkah Anda menandai hanya nilai-nilai yang seharusnya berupa persentase tetapi tidak ada angkanya %? Nilai ini harus benar-benar lebih besar dari 1,00, tetapi tanpa tambahan %. (Nomor tidak boleh berisi lebih dari dua digit sebelum atau sesudah koma.) <mark>Perhatikan</mark> bahwa solusi ini sangat sulit . Jika Anda dapat menyelesaikan soal ini tanpa melihat jawaban saya, maka Anda sudah memiliki keterampilan hebat dalam ekspresi reguler!

pola:
string: 0,32 100,00 5,6 0,27 98% 12,2% 1,01 0,99% 0,99 13,13 1,10 
cocok:      ^^^^^ ^^^ ^^^^ ^^^^^ ^^^^ 
grup:         111111 111 1111 11111 1111    

( Solusi ) <h2>Langkah 19: Kondisi dalam Ekspresi Reguler</h2> Kita sekarang telah mencapai titik di mana kebanyakan orang tidak lagi menggunakan ekspresi reguler. Kami mungkin telah membahas 95% kasus penggunaan ekspresi reguler sederhana, dan semua yang dilakukan pada langkah 19 dan 20 biasanya dilakukan dengan bahasa manipulasi teks berfitur lengkap seperti awk atau sed (atau bahasa pemrograman tujuan umum). Karena itu, mari kita lanjutkan, supaya Anda tahu apa yang sebenarnya bisa dilakukan oleh ekspresi reguler. Meskipun ekspresi reguler tidak lengkap Turing , beberapa mesin ekspresi reguler menawarkan fitur yang sangat mirip dengan bahasa pemrograman lengkap. Salah satu fitur tersebut adalah "kondisi". Persyaratan regex memperbolehkan pernyataan if-then-else, dengan cabang yang dipilih ditentukan oleh "melihat ke depan" atau "melihat ke belakang" yang kita pelajari pada langkah sebelumnya. Misalnya, Anda mungkin ingin mencocokkan hanya entri yang valid dalam daftar tanggal:

pola: (?<=Feb )([1-2][0-9])|(?<=Mar )([1-2][0-9]|3[0-1]) 
string: Tanggal bekerja : 28 Feb , 29 Feb , 30 Feb, 30 Mar, 31 Mar  
Pertandingan:                   ^^ ^^ ^^ ^^ 
grup:                      11 11 22 22    

( Contoh ) <mark>Perhatikan</mark> bahwa grup di atas juga diindeks berdasarkan bulan. Kita dapat menulis ekspresi reguler untuk seluruh 12 bulan dan hanya menangkap tanggal yang valid, yang kemudian akan digabungkan ke dalam kelompok yang diindeks berdasarkan bulan dalam setahun. Di atas menggunakan struktur seperti if yang hanya akan mencari kecocokan di grup pertama jika "Februari" mendahului angka (dan demikian pula untuk grup kedua). Namun bagaimana jika kita hanya ingin menggunakan pengolahan khusus untuk bulan Februari? Sesuatu seperti "jika angkanya diawali dengan "Feb", lakukan ini, jika tidak, lakukan hal lain ini." Inilah cara kondisional melakukannya:

pola: (?(?<=Februari )([1-2][0-9])|([1-2][0-9]|3[0-1])) 
string: Tanggal bekerja: 28 Feb , 29 Feb , 30 Feb, 30 Mar, 31 Mar  
Pertandingan:                   ^^ ^^ ^^ ^^ 
grup:                      11 11 22 22    

( Contoh ) Struktur if-then-else terlihat seperti (?(If)then|else), dimana (if) diganti dengan "look forward" atau "look back". Dalam contoh di atas, (jika) ditulis sebagai (?<=Feb). Anda dapat melihat bahwa kami mencocokkan tanggal yang lebih besar dari 29, tetapi hanya jika tanggal tersebut tidak mengikuti "Februari". Menggunakan lookbehinds dalam ekspresi kondisional berguna jika Anda ingin memastikan bahwa kecocokan didahului oleh beberapa teks. Persyaratan pandangan ke depan positif dapat membingungkan karena kondisi itu sendiri tidak cocok dengan teks mana pun. Jadi jika Anda ingin kondisi if memiliki nilai, maka kondisi tersebut harus sebanding dengan tampilan ke depan seperti di bawah ini:

pola: (?(?=tepat)tepat|lainnya)wo 
string: tepat lagi tepat dua yang lain  
cocok:            ^^^^^^^ ^^^^^^

( Contoh ) Artinya, kondisi pandangan ke depan yang positif tidak ada gunanya. Anda memeriksa untuk melihat apakah teks itu ada di depan dan kemudian memberikan pola yang cocok untuk diikuti ketika teks itu berada di depan. Ekspresi kondisional sama sekali tidak membantu kita di sini. Anda juga bisa mengganti ekspresi di atas dengan ekspresi reguler yang lebih sederhana:

pola: (?:tepat|lainnya)wo 
string: tepat lain tepat dua yang lain  
cocok:            ^^^^^^^ ^^^^^^

( Contoh ) Jadi, aturan praktis untuk ekspresi kondisional adalah: tes, tes, dan tes lagi. Jika tidak, solusi yang menurut Anda jelas akan gagal dengan cara yang paling menarik dan tidak terduga :) <h3>Di sini kita sampai pada blok tugas terakhir yang memisahkan kita dari langkah terakhir, langkah ke-20:</h3> Tulis ekspresi reguler yang menggunakan ekspresi kondisional lookahead negatif untuk menguji apakah kata berikutnya diawali dengan huruf kapital. Jika iya, ambil satu huruf kapital saja, lalu huruf kecil. Jika tidak, ambil karakter kata apa saja.

pola:
string:   Jones Smith 9sfjn Hobbes 23r4tgr9h CSV Csv vVv 
pertandingan: ^^^^^ ^^^^^ ^^^^^ ^^^^^ ^^^^^^^^^ ^^^ ^^^ 
grup:    22222 22222 11111 222222 111111111 222 111    

( Solusi ) Tulis ekspresi kondisional tampilan belakang negatif yang menangkap teks ownshanya jika tidak didahului oleh teks cl, dan menangkap teks oudshanya jika didahului oleh teks cl. (Sedikit contoh yang dibuat-buat, tapi apa yang bisa Anda lakukan...)

pola:
string: Badut-badut itu memiliki beberapa awan . keluar.
cocok:              ^^^^ ^^^^   

( Solusi ) <h2>Langkah 20: Rekursi dan Studi Lebih Lanjut</h2> Faktanya, ada banyak hal yang dapat dimasukkan ke dalam 20 langkah pengenalan topik apa pun, dan ekspresi reguler tidak terkecuali. Ada banyak implementasi dan standar ekspresi reguler berbeda yang dapat ditemukan di Internet. Jika Anda ingin mempelajari lebih lanjut, saya sarankan Anda memeriksa situs regularexpressions.info yang luar biasa , ini adalah referensi yang luar biasa dan saya tentu saja belajar banyak tentang ekspresi reguler dari sana. Saya sangat merekomendasikannya, serta regex101.com untuk menguji dan menerbitkan kreasi Anda. Pada langkah terakhir ini, saya akan memberikan sedikit pengetahuan lagi tentang ekspresi reguler, yaitu cara menulis ekspresi rekursif. Rekursi sederhana cukup sederhana, tapi mari kita pikirkan apa artinya dalam konteks ekspresi reguler. Sintaks untuk rekursi sederhana dalam ekspresi reguler ditulis seperti ini: (?R)?. Namun, tentu saja, sintaksis ini harus muncul di dalam ekspresi itu sendiri. Apa yang akan kita lakukan adalah menyarangkan ekspresi ke dalam ekspresi itu sendiri, beberapa kali. Misalnya:

pola: (hei(?R)?oh) 
string:   heyoh heyyoh heyheyohoh hei oh heyhey hey heyheyohoh  
kecocokan: ^^^^^ ^^^^^^^^^ ^^^^^^^^^^ 
grup:    11111 1111111111 1111111111    

( Contoh ) Karena ekspresi yang disarangkan bersifat opsional ( (?R)diikuti ?), pencocokan yang paling sederhana adalah dengan mengabaikan rekursi sepenuhnya. Jadi, hey, lalu ohcocokkan ( heyoh). Untuk mencocokkan ekspresi yang lebih kompleks dari ini, kita harus menemukan substring yang cocok yang bersarang di dalam dirinya sendiri pada titik dalam ekspresi di mana kita menyisipkan (?R)urutannya. Dengan kata lain, kita bisa menemukan heyheyohoh atau heyheyheyohohoh, dan seterusnya. Salah satu hal hebat tentang ekspresi bertumpuk ini adalah, tidak seperti referensi balik dan grup penangkap bernama, ekspresi tersebut tidak membatasi Anda pada teks persis yang Anda cocokkan sebelumnya, karakter demi karakter. Misalnya:

pola: ([Hh][Ee][Yy](?R)?oh) 
string:   heyoh heyyoh hEyHeYohoh hey oh heyhey hEyHeYHEyohohoh  
cocok: ^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^ 
grup:    11111 1111111111 111111111111111    

( Contoh ) Anda dapat membayangkan bahwa mesin ekspresi reguler menyalin dan menempelkan ekspresi reguler Anda ke dalam dirinya sendiri beberapa kali. Tentu saja, ini berarti terkadang hal tersebut tidak memberikan hasil yang Anda harapkan:

pola: ((?:\(\*)[^*)]*(?R)?(?:\*\))) 
string: (* komentar (* bersarang *) bukan *)
pertandingan:            ^^^^^^^^^^^^ 
grup:               111111111111    

( Contoh ) Dapatkah Anda mengetahui mengapa regex ini hanya menangkap komentar bersarang dan bukan komentar luar? Satu hal yang pasti: saat menulis ekspresi reguler yang kompleks, selalu uji ekspresi tersebut untuk memastikan ekspresi tersebut berfungsi sesuai keinginan Anda. Reli berkecepatan tinggi di sepanjang jalan ekspresi reguler telah berakhir. Saya harap Anda menikmati perjalanan ini. Baiklah, dan terakhir, saya akan meninggalkan di sini, seperti yang saya janjikan di awal, beberapa tautan berguna untuk mempelajari materi lebih mendalam:

• Ekspresi reguler di Java (Artikel oleh Alex)
• Ekspresi reguler di Java (Terjemahan artikel oleh Jeff Friesen dari Elleanor Kerry)
• Contoh ekspresi reguler java (dengan tabel sintaksis yang mudah digunakan)
• Pengukur Serakah dan Malas (Contoh JavaScript)
• 25 Ekspresi Reguler yang Paling Banyak Digunakan di Java
• RegexOne (Tugas dengan pemeriksaan)
• Jangan takut dengan ekspresi reguler. Regex dalam 20 menit! (bagi mereka yang lebih suka tutorial video)