RegEx: 20 langkah pendek untuk menguasai ungkapan biasa. Bahagian 4

RegEx: 20 langkah pendek untuk menguasai ungkapan biasa. Bahagian 1 RegEx: 20 langkah pendek untuk menguasai ungkapan biasa. Bahagian 2 20 langkah pendek untuk menguasai ungkapan biasa. Bahagian 3 Bahagian akhir ini, di tengah, akan menyentuh perkara yang digunakan terutamanya oleh pakar ungkapan biasa. Tetapi bahan dari bahagian sebelumnya adalah mudah untuk anda, bukan? Ini bermakna anda boleh mengendalikan bahan ini dengan mudah! Asal di sini <h2>Langkah 16: kumpulan tanpa menangkap (?:)</h2> Dalam dua contoh dalam langkah sebelumnya, kami menangkap teks yang tidak kami perlukan. Dalam tugasan Saiz Fail, kami menangkap ruang sebelum digit pertama saiz fail dan dalam tugasan CSV, kami menangkap koma antara setiap token. Kita tidak perlu menangkap aksara ini, tetapi kita perlu menggunakannya untuk menstruktur ungkapan biasa kita. Ini adalah pilihan ideal untuk menggunakan kumpulan tanpa menangkap, (?:). Kumpulan yang tidak menangkap melakukan dengan tepat seperti bunyinya - ia membenarkan aksara dikumpulkan dan digunakan dalam ungkapan biasa, tetapi tidak menangkapnya dalam kumpulan bernombor:

pattern: (?:")([^"]+)(?:") 
rentetan: Saya hanya mahu "teks di dalam petikan ini" .
perlawanan:             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
kumpulan:                 11111111111111111111111111111    

( Contoh ) Ungkapan biasa kini sepadan dengan teks yang dipetik serta aksara petikan itu sendiri, tetapi kumpulan tangkapan hanya menangkap teks yang dipetik. Mengapa kita harus melakukan ini? Intinya ialah kebanyakan enjin ungkapan biasa membenarkan anda memulihkan teks daripada kumpulan tangkapan yang ditakrifkan dalam ungkapan biasa anda. Jika kita boleh memangkas aksara tambahan yang tidak kita perlukan tanpa memasukkannya dalam kumpulan tangkapan kita, ia akan memudahkan untuk menghuraikan dan memanipulasi teks kemudian. Berikut ialah cara untuk membersihkan penghurai CSV daripada langkah sebelumnya:

corak: (?:^|,)\s*(?:\"([^",]*)\"|([^", ]*)) 
rentetan:   a , " b ", " cd ", e , f , " gh ", dfgi ,, k , "", l 
padanan: ^ ^ ^^^ ^ ^ ^^^ ^^^^ ^ ^ 
kumpulan:    2 1 111 2 2 111 2222 2 2    

( Contoh ) Terdapat beberapa perkara untuk <tanda>perhatikan di sini:</mark> Pertama, kami tidak lagi menangkap koma kerana kami menukar kumpulan menangkap (^|,)kepada kumpulan bukan menangkap (?:^|,). Kedua, kami menyarangkan kumpulan tangkapan dalam kumpulan bukan tangkapan. Ini berguna apabila, sebagai contoh, anda memerlukan sekumpulan aksara untuk muncul dalam susunan tertentu, tetapi anda hanya mengambil berat tentang subset aksara tersebut. Dalam kes kami, kami memerlukan aksara bukan petikan dan bukan koma [^",]*untuk muncul dalam petikan, tetapi kami sebenarnya tidak memerlukan aksara petikan itu sendiri, jadi ia tidak perlu ditangkap. Akhir sekali, <mark>nota</mark> bahawa dalam contoh di atas terdapat juga padanan sifar panjang antara aksara kdan l. Petikan ""ialah subrentetan yang dicari, tetapi tiada aksara antara petikan, jadi subrentetan yang sepadan tidak mengandungi aksara (panjang sifar). <h3>Adakah kita akan menyatukan pengetahuan kita? Berikut ialah dua setengah tugasan yang akan membantu kami dalam hal ini:</h3> Menggunakan kumpulan bukan menangkap (dan menangkap kumpulan, dan kelas aksara, dll.), tulis ungkapan biasa yang menangkap hanya saiz fail yang diformat dengan betul pada baris di bawah:

corak:
rentetan:   6.6KB 1..3KB 12KB 5G 3.3MB KB .6.2TB 9MB .
perlawanan: ^^^^^ ^^^^^ ^^^^^^ ^^^^ 
kumpulan:    11111 1111 11111 111    

( Penyelesaian ) Tag pembuka HTML bermula dengan <dan berakhir dengan >. Tag penutup HTML bermula dengan urutan aksara </dan berakhir dengan aksara >. Nama tag terkandung di antara aksara ini. Bolehkah anda menulis ungkapan biasa untuk menangkap hanya nama dalam tag berikut? (Anda mungkin boleh menyelesaikan masalah ini tanpa menggunakan kumpulan yang tidak menangkap. Cuba selesaikan dua cara ini! Sekali dengan kumpulan dan sekali tanpa.)

corak:
rentetan:   <p> </span> <div> </kbd> <link> 
padanan: ^^^ ^^^^^^ ^^^^^ ^^^^^^ ^^^^^^ 
kumpulan:    1 1111 111 111 1111    

( Penyelesaian menggunakan kumpulan bukan tangkap ) ( Penyelesaian tanpa menggunakan kumpulan bukan tangkap ) <h2>Langkah 17: Pautan balik \Ndan dinamakan kumpulan tangkap</h2> Walaupun saya memberi amaran kepada anda dalam pengenalan bahawa cuba mencipta penghurai HTML menggunakan ungkapan biasa biasanya membawa kepada sakit hati, contoh terakhir ini adalah segue yang bagus kepada satu lagi (kadang-kadang) ciri berguna bagi kebanyakan ungkapan biasa: rujukan belakang. Pautan balik adalah seperti kumpulan berulang di mana anda boleh cuba menangkap teks yang sama dua kali. Tetapi mereka berbeza dalam satu aspek penting - mereka hanya akan menangkap teks yang sama, watak demi watak. Walaupun kumpulan berulang akan membolehkan kami menangkap sesuatu seperti ini:

corak: (dia(?:[az])+) 
rentetan:   heyabcdefg hey heyo heyellow heyyyyyyyyy 
padanan: ^^^^^^^^^^ ^^^ ^^^^ ^^^^^^^^ ^^^ ^^^^^^^^ 
kumpulan:    1111111111 111 1111 11111111 11111111111    

( Contoh ) ...maka pautan balik akan sepadan dengan ini sahaja:

corak: (dia([az])(\2+)) 
rentetan: heyabcdefg hey heyo heyellow heyyyyyyyyy 
padanan:                              ^^^^^^^^^^^ 
kumpulan:                                 11233333333    

( Contoh ) Kumpulan tangkapan berulang berguna apabila anda ingin memadankan corak yang sama berulang kali, manakala pautan balik bagus apabila anda ingin memadankan teks yang sama. Sebagai contoh, kami boleh menggunakan pautan balik untuk cuba mencari tag pembuka dan penutup HTML yang sepadan:

corak: <(\w+)[^>]*>[^<]+<\/\1> 
rentetan:   <span style="color: red">hey</span> 
padanan: ^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
kumpulan:    1111    

( Contoh ) <mark>Sila ambil perhatian</mark> bahawa ini adalah contoh yang sangat mudah dan saya amat mengesyorkan agar anda tidak cuba menulis penghurai HTML berasaskan ungkapan biasa. Ini sintaks yang sangat kompleks dan kemungkinan besar akan membuat anda sakit. Kumpulan tangkapan yang dinamakan sangat serupa dengan pautan balik, jadi saya akan membincangkannya secara ringkas di sini. Satu-satunya perbezaan antara rujukan belakang dan kumpulan tangkap bernama ialah... kumpulan tangkap bernama mempunyai nama:

corak: <(?<tag>\w+)[^>]*>[^<]+<\/(?P=tag)></tag> 
rentetan:   <span style="color: red">hai< /span> 
padanan: ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
kumpulan:    1111    

( Contoh ) Anda boleh mencipta kumpulan penangkap bernama menggunakan (?<name>...) atau (?'name'...) sintaks (.NET-compatible regular expression) atau dengan sintaks ini (?P<name>. ..) atau (?P'name'...) (Ungkapan biasa yang serasi dengan Python). Memandangkan kami menggunakan PCRE (Perl Compatible Regular Expression) yang menyokong kedua-dua versi, kami boleh menggunakan salah satu di sini. (Java 7 menyalin sintaks .NET, tetapi hanya versi kurungan sudut. Nota penterjemah) Untuk mengulang kumpulan penangkap bernama kemudian dalam ungkapan biasa, kami menggunakan \<kname> atau \k'name' (.NET) atau (? P= nama) (Python). Sekali lagi, PCRE menyokong semua pilihan yang berbeza ini. Anda boleh membaca lebih lanjut tentang kumpulan tangkap yang dinamakan di sini , tetapi ini adalah sebahagian besar daripada perkara yang anda perlu tahu tentang mereka. <h3>Tugas untuk membantu kami:</h3> Gunakan pautan balik untuk membantu saya mengingati... ummm... nama orang ini.

corak:
rentetan: "Hai nama saya Joe." [kemudian] "Siapa nama lelaki itu? Joe ?"
padanan:        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^ 
kumpulan:                  111    

( Penyelesaian ) <h2>Langkah 18: pandang ke hadapan dan pandang belakang</h2> Sekarang kita akan menyelami beberapa ciri lanjutan ungkapan biasa. Saya menggunakan segala-galanya sehingga langkah 16 agak kerap. Tetapi beberapa langkah terakhir ini hanya untuk orang yang menggunakan regex dengan sangat serius untuk memadankan ungkapan yang sangat kompleks. Dalam erti kata lain, menguasai ungkapan biasa. "Melihat Ke Hadapan" dan "Melihat Ke Belakang" mungkin kelihatan agak rumit, tetapi ia sebenarnya tidak terlalu rumit. Mereka membenarkan anda melakukan sesuatu yang serupa dengan apa yang kami lakukan dengan kumpulan yang tidak menangkap sebelum ini - semak sama ada terdapat sebarang teks sejurus sebelum atau sejurus selepas teks sebenar yang ingin kami padankan. Sebagai contoh, katakan kita mahu memadankan hanya nama perkara yang disukai orang, tetapi hanya jika mereka bersemangat mengenainya (hanya jika mereka mengakhiri ayat mereka dengan tanda seru). Kita boleh melakukan sesuatu seperti:

corak: (\w+)(?=!) 
rentetan: Saya suka meja. Saya menghargai stapler. Saya suka lampu !
perlawanan:                                           ^^^^ 
kumpulan:                                              1111    

( Contoh ) Anda boleh melihat bagaimana kumpulan tangkapan di atas (\w+), yang biasanya sepadan dengan mana-mana perkataan dalam petikan, hanya sepadan dengan lampu perkataan. Pandangan ke hadapan yang positif (?=!)bermakna kita hanya boleh memadankan urutan yang berakhir !tetapi kita sebenarnya tidak sepadan dengan watak tanda seru itu sendiri. Ini adalah perbezaan yang penting kerana dengan kumpulan yang tidak menangkap kita memadankan watak tetapi tidak menangkapnya. Dengan pandangan ke hadapan dan ke belakang, kami menggunakan watak untuk membina ungkapan biasa kami, tetapi kemudian kami tidak memadankannya dengan dirinya sendiri. Kita boleh memadankannya kemudian dalam ungkapan biasa kita. Terdapat empat jenis pandangan ke hadapan dan ke belakang: pandangan positif (?=...), pandangan negatif (?!...), pandangan positif (?<=...) dan pandangan negatif (?<!. ..) . Mereka melakukan apa yang mereka dengar - pandang ke hadapan dan pandang belakang positif membenarkan enjin ungkapan biasa untuk terus memadankan hanya apabila teks yang terkandung dalam pandangan ke hadapan/pandang belakang benar-benar sepadan. Pandangan negatif ke hadapan dan pandang belakang melakukan sebaliknya - mereka membenarkan regex untuk dipadankan hanya apabila teks yang terkandung dalam lookahead/pandang belakang tidak sepadan. Sebagai contoh, kami ingin memadankan nama kaedah hanya dalam rangkaian urutan kaedah, bukan objek yang dikendalikannya. Dalam kes ini, setiap nama kaedah mesti didahului dengan .. Ungkapan biasa menggunakan pandangan ke belakang yang mudah boleh membantu di sini:

corak: (?<=\.)(\w+) 
rentetan: myArray. flatMap.aggregate.summarise.print !
perlawanan:         ^^^^^^^ ^^^^^^^^^ ^^^^^^^^^ ^^^^^ 
kumpulan:            1111111 111111111 111111111 11111    

( Contoh ) Dalam teks di atas, kami memadankan sebarang urutan aksara perkataan \w+, tetapi hanya jika ia didahului oleh aksara itu .. Kita boleh mencapai sesuatu yang serupa menggunakan kumpulan bukan penangkapan, tetapi hasilnya lebih kucar-kacir:

corak: (?:\.)(\w+) 
rentetan: myArray .flatMap.aggregate.summarise.print !
perlawanan:        ^^^^^^^^ ^^^^^^^^^ ^^^^^^^^^ ^^^^^ 
kumpulan:            1111111 111111111 111111111 11111    

( Contoh ) Walaupun ia lebih pendek, ia sepadan dengan watak yang kita tidak perlukan. Walaupun contoh ini mungkin kelihatan remeh, pandangan ke hadapan dan pandangan di belakang benar-benar boleh membantu kami membersihkan ekspresi biasa kami. <h3>Terdapat sedikit sahaja lagi sehingga tamat! 2 tugasan berikut akan membawa kita 1 langkah lebih dekat kepadanya:</h3> Pandangan negatif di belakang (?<!...) membenarkan enjin ungkapan biasa untuk terus mencuba mencari padanan hanya jika teks yang terkandung di dalam pandangan belakang negatif tidak dipaparkan sehingga seluruh teks , yang anda perlukan untuk mencari padanan. Sebagai contoh, kita boleh menggunakan ungkapan biasa untuk memadankan hanya nama keluarga wanita yang menghadiri persidangan. Untuk melakukan ini, kami ingin memastikan bahawa nama keluarga orang itu tidak didahului oleh Mr.. Bolehkah anda menulis ungkapan biasa untuk ini? (Nama akhir boleh diandaikan sekurang-kurangnya empat aksara panjang.)

corak:
tali: En. Brown, Pn. Smith , Pn. Jones , Cik Daisy , En. hijau
perlawanan:                ^^^^^ ^^^^^ ^^^^^ 
kumpulan:                   11111 11111 11111    

( Penyelesaian ) Katakan kami mengosongkan pangkalan data dan kami mempunyai lajur maklumat yang mewakili peratusan. Malangnya, sesetengah orang menulis nombor sebagai nilai perpuluhan dalam julat [0.0, 1.0], manakala yang lain menulis peratusan dalam julat [0.0%, 100.0%], dan yang lain menulis nilai peratusan. tetapi terlupa tanda peratus literal %. Menggunakan pandangan negatif (?!...), bolehkah anda menandakan hanya nilai yang sepatutnya peratusan tetapi tiada digit %? Ini mestilah nilai yang lebih besar daripada 1.00, tetapi tanpa ketinggalan %. (Tiada nombor boleh mengandungi lebih daripada dua digit sebelum atau selepas titik perpuluhan.) <mark>Perhatikan</mark> bahawa penyelesaian ini amat sukar . Jika anda boleh menyelesaikan masalah ini tanpa melihat jawapan saya, maka anda sudah mempunyai kemahiran besar dalam ungkapan biasa!

corak:
rentetan: 0.32 100.00 5.6 0.27 98% 12.2% 1.01 0.99% 0.99 13.13 1.10 
padanan:      ^^^^1 ^^^ ^^^^ ^^^^^ ^^^^ 
kumpulan:         111111 111 1111    

( Penyelesaian ) <h2>Langkah 19: Syarat dalam Ungkapan Biasa</h2> Kami kini telah mencapai tahap di mana kebanyakan orang tidak lagi menggunakan ungkapan biasa. Kami telah merangkumi mungkin 95% daripada kes penggunaan untuk ungkapan biasa yang mudah, dan semua yang dilakukan dalam langkah 19 dan 20 biasanya dilakukan oleh bahasa manipulasi teks yang lebih berciri penuh seperti awk atau sed (atau bahasa pengaturcaraan tujuan umum). Oleh itu, mari kita teruskan, supaya anda tahu apa yang boleh dilakukan oleh ungkapan biasa. Walaupun ungkapan biasa tidak lengkap Turing , beberapa enjin ungkapan biasa menawarkan ciri yang hampir sama dengan bahasa pengaturcaraan yang lengkap. Satu ciri sedemikian ialah "keadaan". Syarat regex membenarkan pernyataan if-then-else, di mana cawangan yang dipilih ditentukan oleh sama ada "pandang ke hadapan" atau "pandang ke belakang" yang kita pelajari dalam langkah sebelumnya. Sebagai contoh, anda mungkin mahu memadankan hanya entri yang sah dalam senarai tarikh:

corak: (?<=Feb )([1-2][0-9])|(?<=Mac )([1-2][0-9]|3[0-1]) 
rentetan: Tarikh berfungsi : 28 Feb , 29 Feb , 30 Feb, 30 Mac , 31 Mac  
perlawanan:                   ^^ ^^ ^^ ^^ 
kumpulan:                      11 11 22 22    

( Contoh ) <mark>Nota</mark> bahawa kumpulan di atas juga diindeks mengikut bulan. Kami boleh menulis ungkapan biasa untuk semua 12 bulan dan hanya menangkap tarikh yang sah, yang kemudiannya akan digabungkan ke dalam kumpulan yang diindeks mengikut bulan dalam setahun. Di atas menggunakan sejenis struktur seperti jika yang hanya akan mencari padanan dalam kumpulan pertama jika "Feb" mendahului nombor (dan begitu juga untuk yang kedua). Tetapi bagaimana jika kita hanya mahu menggunakan pemprosesan khas untuk bulan Februari? Sesuatu seperti "jika nombor didahului dengan "Feb", lakukan ini, jika tidak lakukan perkara lain ini." Begini cara bersyarat melakukannya:

corak: (?(?<=Feb )([1-2][0-9])|([1-2][0-9]|3[0-1])) 
rentetan: Tarikh berfungsi: 28 Feb , 29 Feb , 30 Feb, 30 Mac, 31 Mac  
perlawanan:                   ^^ ^^ ^^ ^^ 
kumpulan:                      11 11 22 22    

( Contoh ) Struktur if-then-else kelihatan seperti (?(If)then|else), di mana (jika) digantikan dengan "pandang ke hadapan" atau "pandang ke belakang". Dalam contoh di atas, (jika) ditulis sebagai (?<=Feb). Anda boleh melihat bahawa kami memadankan tarikh lebih daripada 29, tetapi hanya jika tarikh tersebut tidak mengikuti "Feb". Menggunakan look belakang dalam ungkapan bersyarat berguna jika anda ingin memastikan bahawa padanan didahului oleh beberapa teks. Syarat pandang ke hadapan yang positif boleh mengelirukan kerana syarat itu sendiri tidak sepadan dengan mana-mana teks. Jadi, jika anda mahu syarat if mempunyai nilai, ia mesti setanding dengan melihat ke hadapan seperti di bawah:

corak: (?(?=tepat)tepat|lain)wo 
rentetan: exact else exactwo elsewo  
padanan:            ^^^^^^^ ^^^^^^

( Contoh ) Ini bermakna syarat berpandangan positif tidak berguna. Anda menyemak untuk melihat sama ada teks itu berada di hadapan dan kemudian memberikan corak yang sepadan untuk diikuti apabila ia berada. Ungkapan bersyarat tidak membantu kami di sini sama sekali. Anda juga boleh menggantikan yang di atas dengan ungkapan biasa yang lebih mudah:

corak: (?:exact|else)wo 
rentetan: exact else exactwo elsewo  
padanan:            ^^^^^^^ ^^^^^^

( Contoh ) Jadi, peraturan praktikal untuk ungkapan bersyarat ialah: uji, uji dan uji semula. Jika tidak, penyelesaian yang anda fikir jelas akan gagal dalam cara yang paling menarik dan tidak dijangka :) <h3>Di sini kita sampai ke blok tugasan terakhir yang memisahkan kita daripada langkah ke-20 yang terakhir:</h3> Tulis ungkapan biasa yang menggunakan ungkapan bersyarat pandangan ke hadapan negatif untuk menguji sama ada perkataan seterusnya bermula dengan huruf besar. Jika ya, ambil hanya satu huruf besar dan kemudian huruf kecil. Jika tidak, ambil sebarang aksara perkataan.

corak:
rentetan:   Jones Smith 9sfjn Hobbes 23r4tgr9h CSV Csv vVv 
padanan: ^^^^^ ^^^^^ ^^^^^ ^^^^^^ ^^^^^^^^^ ^^^ ^^^ 
kumpulan:    22222 22222 11111 222222 111111111 222 111    

( Penyelesaian ) Tulis pandangan negatif di belakang ungkapan bersyarat yang menangkap teks ownshanya jika ia tidak didahului oleh teks cl, dan menangkap teks oudshanya apabila ia didahului oleh teks cl. (Sedikit contoh rekaan, tetapi apa yang boleh anda lakukan...)

corak:
rentetan: Badut-badut itu memiliki beberapa ilmu . ouds.
perlawanan:              ^^^^ ^^^^   

( Penyelesaian ) <h2>Langkah 20: Rekursi dan Kajian Lanjut</h2> Sebenarnya, terdapat banyak perkara yang boleh dimasukkan ke dalam pengenalan 20 langkah kepada mana-mana topik, dan ungkapan biasa tidak terkecuali. Terdapat banyak pelaksanaan dan piawaian yang berbeza untuk ungkapan biasa yang boleh didapati di Internet. Jika anda ingin mengetahui lebih lanjut, saya cadangkan anda menyemak tapak yang indah regularexpressions.info , ia adalah rujukan yang hebat dan saya sudah tentu belajar banyak tentang ungkapan biasa dari sana. Saya sangat mengesyorkannya, serta regex101.com untuk menguji dan menerbitkan ciptaan anda. Dalam langkah terakhir ini, saya akan memberi anda sedikit lagi pengetahuan tentang ungkapan biasa, iaitu cara menulis ungkapan rekursif. Rekursi mudah agak mudah, tetapi mari kita fikirkan maksudnya dalam konteks ungkapan biasa. Sintaks untuk rekursi mudah dalam ungkapan biasa ditulis seperti ini: (?R)?. Tetapi, sudah tentu, sintaks ini mesti muncul dalam ungkapan itu sendiri. Apa yang akan kita lakukan ialah menyarangkan ungkapan itu dalam dirinya, sewenang-wenangnya beberapa kali. Sebagai contoh:

corak: (hey(?R)?oh) 
rentetan:   heyoh heyyoh heyheyohoh hey oh heyhey hey heyheyohoh  
padanan: ^^^^^ ^^^^^^^^^^ ^^^^^^^^^^ 
kumpulan:    11111 1111111111 1111111111    

( Contoh ) Memandangkan ungkapan bersarang adalah pilihan ( (?R)diikuti ?), padanan yang paling mudah ialah mengabaikan rekursi sepenuhnya. Jadi, hey, dan kemudian ohpadankan ( heyoh). Untuk memadankan mana-mana ungkapan yang lebih kompleks daripada ini, kita mesti mendapati bahawa padanan subrentetan bersarang di dalam dirinya pada titik dalam ungkapan di mana kita memasukkan (?R)jujukan. Dalam erti kata lain, kita boleh mencari heyheyohoh atau heyheyheyohohoh, dan sebagainya. Salah satu perkara hebat tentang ungkapan bersarang ini ialah, tidak seperti rujukan belakang dan kumpulan penangkap bernama, mereka tidak mengehadkan anda kepada teks tepat yang anda padankan sebelum ini, aksara demi aksara. Sebagai contoh:

corak: ([Hh][Ee][Yy](?R)?oh) 
rentetan:   heyoh heyyoh hEyHeYohoh hey oh heyhey hEyHeYHEyohohoh  
padanan: ^^^^^ ^^^^^^^^^^ ^^^^^ ^^^^^^^^^^ 
kumpulan:    11111 1111111111 1111111111111111    

( Contoh ) Anda boleh bayangkan bahawa enjin ungkapan biasa secara literal menyalin dan menampal ungkapan biasa anda ke dalam dirinya beberapa kali sewenang-wenangnya. Sudah tentu, ini bermakna kadangkala ia mungkin tidak melakukan apa yang anda harapkan:

corak: ((?:\(\*)[^*)]*(?R)?(?:\*\))) 
rentetan: (* ulasan (* bersarang *) bukan *)
perlawanan:            ^^^^^^^^^^^^ 
kumpulan:               111111111111    

( Contoh ) Bolehkah anda tahu mengapa regex ini hanya menangkap ulasan bersarang dan bukan ulasan luar? Satu perkara yang pasti: semasa menulis ungkapan biasa yang kompleks, sentiasa mengujinya untuk memastikan ia berfungsi seperti yang anda fikirkan. Perhimpunan berkelajuan tinggi di sepanjang jalan ungkapan biasa ini telah berakhir. Saya harap anda menikmati perjalanan ini. Nah, dan akhirnya, saya akan pergi dari sini, seperti yang saya janjikan pada mulanya, beberapa pautan berguna untuk kajian bahan yang lebih mendalam:

• Ungkapan biasa dalam Java (Artikel oleh Alex)
• Ungkapan biasa dalam Java (Terjemahan artikel oleh Jeff Friesen daripada Elleanor Kerry)
• Contoh java ungkapan biasa (dengan jadual sintaks yang mudah)
• Pengkuantiti Tamak dan Malas (Contoh JavaScript)
• 25 Ungkapan Biasa Paling Digunakan di Jawa
• RegexOne (Tugas dengan penyemakan)
• Jangan takut dengan ungkapan biasa. Regex dalam 20 minit! (bagi mereka yang lebih suka tutorial video)