Swift dan Regular Expressions: Sintaks

1. Perkenalan

Sederhananya, regular expressions (regex atau regexp singkatnya) adalah cara untuk menentukan pola string. Anda tidak asing lagi dengan fungsi pencarian dan penggantian di editor teks favorit atau IDE Anda. Kamu bisa mencari kata dan frasa yang tepat. Kamu juga bisa mengaktifkan pilihan, seperti case insensitivity, sehingga pencarian kata 'color' juga menemukan 'Color', 'COLOR', dan 'CoLoR'. Tetapi bagaimana jika kamu ingin mencari variasi ejaan dari kata 'warna' (ejaan Amerika: color, ejaan Inggris: colour) tanpa harus melakukan dua pencarian terpisah?

Jika contoh itu terlalu sederhana, bagaimana jika kamu ingin mencari variasi ejaan dari nama bahasa Inggris "Katherine" (Catherine, Katharine, Kathreen, Kathryn, dll. Untuk beberapa nama). Secara umum, kamu mungkin ingin mencari dokumen untuk semua string yang menyerupai angka heksadesimal, tanggal, nomor telepon, alamat email, nomor kartu kredit, dll.

Regular expressions adalah cara yang ampuh untuk (sebagian atau sepenuhnya) mengatasi masalah praktis (dan banyak lainnya) yang melibatkan teks.

Garis besar

Struktur tutorial ini adalah sebagai berikut. Saya akan memperkenalkan konsep inti yang perlu kamu pahami dengan mengadaptasi pendekatan yang digunakan dalam buku teks teoritis (setelah menghilangkan kekakuan atau kesungguhan yang tidak dibutuhkan).  Saya lebih suka pendekatan ini karena memungkinkanmu untuk memasukkan pemahamanmu tentang kemungkinan 70% fungsi yang kamu perlukan, dalam konteks beberapa prinsip dasar. 30% sisanya adalah fitur yang lebih maju yang bisa kamu pelajari nanti atau lewati, kecuali jika Anda ingin menjadi seorang maestro regex.

Ada banyak sintaks yang terkait dengan regular expressions, namun sebagian besar hanya memungkinkanmu menerapkan gagasan inti sesingkat mungkin. Saya akan memperkenalkan ini secara bertahap, daripada menjatuhkan sebuah meja besar atau daftar untuk dihafal.

Daripada melompat langsung ke implementasi Swift, kita akan mengeksplorasi dasar-dasarnya melalui tool online yang hebat yang akan membantumu merancang dan mengevaluasi regular expressions dengan jumlah minimum gesekan dan bagasi yang tidak perlu. Setelah merasa nyaman dengan ide utama, menulis kode Swift pada dasarnya adalah masalah pemetaan pemahamanmu ke API Swift.

Sepanjang, kita akan mencoba menjaga pola pikir pragmatis. Regex bukan tool terbaik untuk setiap situasi pemrosesan string. Dalam prakteknya, kita perlu mengidentifikasi situasi di mana regex bekerja dengan sangat baik dan situasi di mana mereka tidak melakukannya. Ada juga jalan tengah dimana regex dapat digunakan untuk melakukan sebagian pekerjaan (biasanya beberapa prepemrosesan dan penyaringan) dan sisanya diserahkan ke logika algoritmik.

Konsep inti

Regular expressions memiliki dasar teoretis mereka dalam "teori perhitungan", salah satu topik yang dipelajari oleh ilmu komputer, di mana mereka memainkan peran input yang diterapkan pada kelas tertentu dari mesin komputasi abstrak yang disebut finite automatons.

Tenang, kamu tidak perlu mempelajari latar belakang teoritis untuk menggunakan regular expressions secara praktis. Saya hanya menyebutkannya karena pendekatan yang akan saya gunakan untuk awalnya memotivasi regular expressions dari bawah ke atas mencerminkan pendekatan yang digunakan dalam buku teks ilmu komputer untuk mendefinisikan regular expressions "teoritis".

Dengan asumsi kamu memiliki beberapa keakraban dengan rekursi, saya ingin kamu mengingat bagaimana fungsi rekursif didefinisikan. Fungsi didefinisikan dalam bentuk versi sederhana dari dirinya sendiri dan, jika kamu menelusuri melalui definisi rekursif, kamu harus berakhir pada kasus dasar yang didefinisikan secara eksplisit. Saya mengemukakan ini karena definisi kita di bawah ini juga akan bersifat rekursif.

Perhatikan bahwa, ketika kita berbicara tentang string secara umum, secara implisit kita memiliki karakter yang ada dalam pikiran, seperti ASCII, Unicode, dll. Mari berpura-pura pada saat kita hidup di alam semesta dimana string terdiri dari 26 huruf dari huruf kecil alfabet (a, b, ... z) dan tidak ada yang lain.

Aturan

Kita mulai dengan menyatakan bahwa setiap karakter dalam rangkaian ini dapat dianggap sebagai regular expression yang cocok dengan string. Jadi a sebagai regular expression cocok dengan "a" (dianggap sebagai string), b adalah regex yang cocok dengan string "b", dll. Mari kita juga mengatakan bahwa ada regular expression "kosong" Ɛ yang sesuai dengan string kosong "". Kasus seperti itu sesuai dengan "kasus dasar" biasa dari rekursi tersebut.

Sekarang, kita mempertimbangkan peraturan berikut yang membantu kita membuat regular expressions baru dari yang sudah ada:

1. concatenation (yaitu "merangkai bersama") dari dua regular expressions adalah regular expression baru yang sesuai dengan gabungan dua string yang sesuai dengan regular expression aslinya.
2. alternation dari dua regular expression adalah regular expression baru yang cocok dengan salah satu dari dua regular expression yang asli.
3. Kleene star dari regular expression cocok dengan nol atau contoh yang lebih berdekatan dari apa pun yang cocok dengan regular expression aslinya.

Mari kita membuat ini konkret dengan beberapa contoh sederhana dengan string abjad kita.

Contoh 1

Dari aturan 1, a dan b adalah regular expression yang cocok dengan "a" dan "b", berarti ab adalah regular expression yang sesuai dengan string "ab". Karena ab dan c adalah regular expression, abc adalah regular expression yang cocok dengan string "abc", dan seterusnya. Melanjutkan cara ini, kita bisa membuat regular expression panjang yang sewenang-wenang yang cocok dengan string dengan karakter yang sama. Tidak ada hal menarik yang terjadi.

Contoh 2

Dari aturan 2, o dan a regular expression, o|a kecocokan "o" atau "a". Bar vertikal mewakili alternasi. c dan t adalah regular expression dan, dikombinasikan dengan aturan 1, kita dapat menegaskan bahwa c(o|a)t adalah regular expression. Tanda kurung digunakan untuk pengelompokan.

Apa yang cocok? c dan t hanya cocok dengan dirinya sendiri, yang berarti bahwa regex c(o|a)t cocok dengan "c" diikuti oleh "a" atau "o" diikuti oleh "t", misalnya, string "cat" atau "cot". Perhatikan bahwa itu tidak cocok dengan "coat" sebagai o|a hanya cocok dengan "'a" atau "o", tetapi tidak keduanya sekaligus. Sekarang semuanya mulai menarik.

Contoh 3

Dari aturan 3, a* cocok dengan nol atau lebih banyak contoh "a". Ini cocok dengan string kosong atau string "a", "aa", "aaa", dan seterusnya. Mari jalankan peraturan ini bersamaan dengan dua aturan lainnya.

Apa yang cocok dengan ho*t? Ini cocok dengan "ht" (dengan nol contoh "o"), "hot", "hoot", "hooot", dan seterusnya. Bagaimana dengan b(o|a)*? Ini bisa cocok dengan "b" yang diikuti oleh sejumlah contoh "o" dan "a" (termasuk tidak satupun di antaranya). "b", "boa", "baa", "bao", "baooaoaoaoo" hanyalah beberapa dari sejumlah string yang tak terbatas yang sesuai dengan regular expression ini. Perhatikan lagi bahwa tanda kurung digunakan untuk mengelompokkan bersama bagian dari regular expression yang mana * sedang diterapkan.

Contoh 4

Mari coba untuk menemukan regular expression yang cocok dengan string yang sudah ada dalam pikiran kita. Bagaimana kita membuat regular expression yang mengenali domba yang mengembek, yang akan saya anggap sebagai sejumlah pengulangan suara dasar "baa" ("baa", "baabaa", "baabaabaa", dll.)

Jika kamu berkata, (baa)*, maka kamu hampir benar. Tetapi perhatikan bahwa regular expression ini akan cocok dengan string kosong juga, yang tidak kita inginkan. Dengan kata lain, kita ingin mengabaikan domba yang tidak mengembek. baa(baa)* adalah regular expression yang kita cari. Demikian pula, suara moo seokar sapi mungkin moo(moo)*. Bagaimana kita bisa mengenali suara binatang? Sederhana. Gunakan alternasi. baa(baa)*|moo(moo)*

Jika kamu telah memahami gagasan di atas, selamat, kamu sedang dalam perjalanan.

2. Masalah Sintaks

Ingat kembali kita menempatkan batasan konyol pada string kita. Mereka hanya bisa terdiri dari huruf kecil huruf alfabet. Kita sekarang akan menghentikan pembatasan ini dan mempertimbangkan semua string yang terdiri dari karakter ASCII.

Kita harus menyadari bahwa, agar regular expression menjadi tool yang mudah digunakan, mereka sendiri perlu diwakili sebagai string. Jadi, tidak seperti sebelumnya, kita tidak bisa lagi menggunakan karakter seperti *, |, (, ), dll tanpa menandakan apakah kita menggunakannya sebagai karakter "khusus" yang mewakili alternasi, pengelompokan, dll. Atau apakah kita memperlakukannya seperti karakter biasa yang perlu dicocokkan secara harfiah.

Solusinya adalah memperlakukan ini dan 'metakarakter' lainnya yang bisa memiliki arti khusus. Untuk beralih di antara satu kegunaan dan kegunaan yang lainnya, kita harus bisa melepaskan diri daripadanya. Ini mirip dengan gagasan menggunakan "\n" (meloloskan n) untuk menunjukkan baris baru dalam sebuah string. Ini sedikit lebih rumit dalam hal itu, tergantung pada karakter konteks yang biasanya "meta", mungkin mewakili dirinya sendiri tanpa pelolosan. Kita akan melihat contoh-contohnya nanti.

Hal lain yang kita nilai adalah keringkasan. Banyak regular expression yang bisa diungkapkan dengan menggunakan notasi bagian sebelumnya aka menjadi verbose yang membosankan. Misalnya, Kamu hanya ingin menemukan seluruh dua string karakter yang terdiri dari huruf kecil diikuti oleh angka (misalnya, string seperti "a0", "b9", "z3", dll.). Dengan menggunakan notasi yang telah kita bahas sebelumnya, ini akan menghasilkan regular expression berikut ini:

1

(a|b|c|d|e|f|g|h|i|j|k|l|m|n|o|p|q|r|s|t|u|v|w|x|y|z)(0|1|2|3|4|5|6|7|8|9)

Cukup ketik monster yang menghapusku.

Tidakkah [abcdefghijklmnopqrstuvwxyz] [0123456789] terlihat seperti representasi yang lebih baik? Perhatikan metakarakter [ dan ] yang menandakan satu set karakter, yang salah satunya memberi kecocokan positif. Sebenarnya, jika kita menganggap bahwa huruf a sampai z, dan angka 0 sampai 9 terjadi secara berurutan dalam rangkaian ASCII, kita bisa mengurangi regex sampai keren [a-z][0-9].

Dalam batas set karakter, tanda hubung, -, adalah metacharacter lain yang menunjukkan jarak. Perhatikan bahwa kamu dapat menekan beberapa rentang ke dalam sepasang kurung siku yang sama. Sebagai contoh, [0-9a-zA-Z] dapat mencocokkan karakter alfanumerik. 9 dan a (dan z dan A) diperas satu sama lain mungkin terlihat lucu, tapi ingat bahwa regular expression seluruhnya tentang keringkasan dan maknanya jelas.

Berbicara tentang keringkasan, ada cara yang lebih ringkas untuk mewakili kelas karakter terkait tertentu seperti yang akan kita lihat sebentar lagi. Perhatikan bahwa bar alternasi, |, masih valid dan berguna seperti yang akan kita lihat sebentar lagi.

Lebih Banyak Sintaks

Sebelum kita mulai berlatih, mari kita lihat sintaks yang sedikit lebih banyak.

Periode

Periode, ., mencocokan dengan karakter tunggal manapun, kecuali jeda baris. Ini berarti c.t dapat mencocokkan "cat", "crt", "c9t", "c%t", "c.t", "c t", dan seterusnya. Jika kita ingin mencocokkan periode itu sebagai karakter biasa, misalnya untuk mencocokkan string "c.t", kita bisa meloloskan itu (c\.t) atau taruh ini di kelas karakter tersendiri (c[.]t).

Secara umum, gagasan ini berlaku untuk metakarakter lain, seperti [, ], (, ), *, dan lainnya yang belum kita temui.

Tanda kurung

Tanda kurung (( dan )) digunakan untuk pengelompokan seperti yang kita lihat sebelumnya. Kita akan menggunakan kata token yang berarti karakter tunggal atau ekspresi tanda kurung. Alasannya, banyak operator regex bisa diaplikasikan pada keduanya.

Tanda kurung juga digunakan untuk menentukan kelompok tangkapan, memungkinkan kamu untuk mengetahui bagian mana dari kecocokanmu yang ditangkap oleh kelompok tangkapan tertentu di regex. Saya akan berbicara lebih banyak tentang fungsi yang sangat berguna ini nanti.

Tambah

Sebuah + berikut yang mengikuti token adalah satu atau lebih contoh dari token tersebut. Dalam contoh domba yang mengembek kita, baa(baa)* bisa diwakili lebih ringkas seperti (baa)+. Ingat kembali bahwa * itu berarti nol atau lebih kejadian. Perhatikan bahwa (baa)+ berbeda dengan baa+, karena pada awalnya + diaplikasikan pada token baa sedangkan pada yang terakhir itu hanya berlaku untuk huruf a sebelumnya. Yang terakhir, ini cocok dengan string seperti "baa", "baaa", dan "baaaa".

Tanda Tanya

Sebuah ? mengikuti token berarti nol atau satu contoh dari token tersebut.

Praktek

RegExr adalah tool online yang sangat baik untuk bereksperimen dengan regular expression. Ketika kamu merasa nyaman membaca dan menulis kalimat biasa, akan lebih mudah menggunakan API regular expression dari framework Foundation. Meski begitu, akan lebih mudah untuk menguji regular expression -mu secara real-time di website terlebih dahulu.

Kunjungi situs web dan fokus pada bagian utama halaman. Inilah yang akan kamulihat:

Kamu masukkan string biasa pada kotak di bagian atas dan masukkan teks di mana kamu mencari kecocokan.

"/g" di ujung kotak expression bukan bagian dari regular expression. Ini adalah flag yang mempengaruhi perilaku pencocokan keseluruhan mesin regex. Dengan menambahkan "/g" untuk regular expression, mesin pencarian untuk semua kemungkinan kecocokan dari regular expression di dalam teks, yang merupakan perilaku yang kita inginkan. Sorot biru menunjukkan sebuah kecocokan. Mengarahkan kursor mouse ke regular expression adalah cara yang berguna untuk mengingatkanmu tentang arti dari bagian-bagiannya.

Ketahuilah bahwa regular expression datang dalam berbagai rasa, tergantung pada bahasa atau library yang kamu gunakan. Hal ini tidak hanya berarti bahwa sintaksnya bisa sedikit berbeda di antara berbagai rasa, namun juga kemampuan dan fiturnya. Swift, misalnya, menggunakan pola sintaks yang ditentukan oleh ICU. Saya tidak yakin mana rasa yang digunakan dalam RegExr (yang berjalan pada JavaScript), namun dalam lingkup tutorial ini, mereka sangat mirip, jika tidak identik.

Saya juga mendorongmu untuk menjelajahi panel di sisi kiri, yang memiliki banyak informasi yang disajikan dalam mode yang ringkas.

Contoh Praktis Pertama Kita

Untuk menghindari potensi kebingungan, saya harus menyebutkan bahwa, ketika berbicara pencocokan regular expression, kita bisa berarti salah satu dari dua hal:

1. mencari apapun (atau semua) substring dari sebuah string yang cocok dengan regex
2. memeriksa apakah string lengkap atau tidak cocok dengan regular expression

Arti default yang digunakan mesin regex adalah (1). Apa yang telah kita bicarakan sejauh ini adalah (2). Untungnya, sangat mudah untuk menerapkan makna (2) dengan menggunakan diperkenalkan yang akan diperkenalkan kemudian. Jangan khawatir tentang hal ini sekarang.

Mari kita mulai yang sederhana dengan menguji contoh domba yang mengembek kita. Ketikan (baa)+ ke dalam kotak expression dan beberapa contoh untuk menguji kecocokan seperti yang ditunjukkan di bawah ini.

Saya harap kamu mengerti mengapa pencocokan yang berhasil itu benar-benar berhasil dan mengapa yang lain gagal. Bahkan dalam contoh sederhana ini, ada beberapa hal menarik untuk ditunjukkan.

Pencocokan Serakah

Apakah string "baabaa" mengandung satu atau dua pencocokan? Dengan kata lain, setiap individu "baa" cocok atau seluruh "baabaa" adalah satu kecocokan? Ini bermuara pada apakah "pencocokan serakah" sedang dicari atau tidak. Pencocokan serakah mencoba untuk mencocokkan sebanyak mungkin string.

Sekarang mesin regex pencocokan rakus, yang berarti "baabaa" adalah satu kecocokan. Ada cara untuk melakukan pencocokan lamban, tapi itu adalah topik yang lebih maju dan, karena kita sudah memiliki piring yang penuh, kita tidak akan mencakup itu dalam tutorial ini.

Tool RegExr yang meninggalkan celah kecil tetapi terlihat di penyorotan jika dua bagian yang berdekatan dari sebuah string masing-masing secara individual (tetapi tidak secara kolektif) cocok dengan regular expression. Kita akan melihat contoh tindakan ini sedikit.

Huruf besar dan kecil

"Baabaa" gagal karena huruf besar "B". Katakanlah kamu ingin mengizinkan hanya "B" pertama yang menjadi huruf besar, berapakah regular expression yang sesuai? Cobalah untuk mengetahuinya sendiri terlebih dahulu.

Salah satu jawabannya adalah (B|b)aa(baa)*. Ini membantu jika kamu membacanya dengan keras. Huruf besar atau huruf kecil "b", diikuti oleh "aa", diikuti dengan nol atau lebih banyak contoh "baa". Ini bisa dilakukan, tetapi perhatikan bahwa ini bisa dengan cepat menjadi tidak nyaman, terutama jika kita ingin mengabaikan kapitalisasi sama sekali. Sebagai contoh, kita harus menentukan alternatif untuk setiap kasus, yang akan menghasilkan sesuatu yang berat seperti ([Bb][Aa][Aa])+.

Untungnya, mesin regular expression biasanya memiliki pilihan untuk mengabaikan kasus. Dalam kasus RegExr, klik tombol yang bertuliskan "flags" dan centang checkbox "ignore case". Perhatikan bahwa huruf "i" ditambahkan ke daftar pilihan di akhir regular expression. Cobalah beberapa contoh dengan huruf campuran, seperti "bAABaa".

Contoh lain

Mari kita coba untuk merancang kalimat biasa yang dapat menangkap varian dari nama "Katherine". Bagaimana kamu akan mendekati masalah ini? Saya akan menuliskan banyak variasi, Lihatlah bagian-bagian umum, dan kemudian mencoba untuk mengungkapkan dengan variasi kata-kata (dengan penekanan pada alternatif dan huruf pilihan) sebagai urutan. Selanjutnya, saya akan mencoba untuk merumuskan kalimat biasa yang di-asimilasi semua variasi ini.

Mari kita mencobanya dengan daftar variasi: Katherine, Katharine, Catherine, Kathreen, Kathleen, Katryn, dan Catrin. Saya akan menyerahkannya kepadamu untuk menuliskan beberapa hal lagi jika kamu mau. Melihat variasi ini, secara kasar saya dapat mengatakan bahwa:

• nama dimulai dengan "k" atau "c"
• diikuti dengan "at"
• mungkin diikuti "h"
• mungkin diikuti oleh "a" atau "e"
• diikuti salah satu "r" atau "l"
• diikuti oleh salah satu "i", "ee" atau "y"
• dan pasti diikuti oleh "n"
• mungkin "e" pada akhirnya

Dengan ini dalam pikiran, saya bisa datang dengan regular expression berikut:

1

[kc]ath?[ae]?(r|l)(i|ee|y)ne?

Perhatikan bahwa baris pertama "KatherineKatharine" memiliki dua pencocokan tanpa ada pemisah antara mereka. Jika kamu melihatnya dengan seksama di editor teks RegExr, kamu dapat mengamati sedikit pemutus dalam penyorotan di antara dua pencocokan, itulah yang saya bicarakan sebelumnya.

Perhatikan bahwa ekspresi reguler di atas juga cocok nama yang kita tidak mempertimbangkan dan yang mungkin bahkan tidak ada, misalnya, "Cathalin". Dalam konteks sekarang, ini sama sekali tidak mempengaruhi kita secara negatif. Namun dalam beberapa aplikasi, seperti validasi email, kamu ingin lebih spesifik tentang string yang kamu cocokkan dan yang kamu tolak. Ini biasanya menambah kompleksitas dari regular expression.

Lebih Banyak Sintaks dan Contohnya

Sebelum beralih ke Swift, saya ingin membahas beberapa aspek sintaks regular expression.

Representasi Ringkas

Beberapa kelas karakter terkait memiliki representasi ringkas:

• \w karakter alfanumerik, termasuk garis bawah, setara dengan [a-zA-Z0-9_]
• \d mewakili angka, setara dengan [0-9]
• \s mewakili spasi, yaitu spasi, tab, atau jeda baris

Kelas-kelas ini juga memiliki kelas negatif yang sesuai:

• \W mewakili karakter non-alfanumerik dan non-garis bawah
• \D non-angka
• \S karakter non-spasi

Ingatlah kelas-kelas yang tidak disunting dan ingatlah bahwa yang sesuai dikompensasikan sesuai dengan apa yang tidak sesuai dengan kelas yang tidak disortir. Perhatikan bahwa ini dapat digabungkan dengan memasukkan tanda kurung siku jika perlu. Sebagai contoh, [\s\S] mewakili karakter apapun, termasuk jeda baris. Ingatlah bahwa periode . cocok pada setiap karakter kecuali jeda baris.

Jangkar

^ dan $ jangkar yang mewakili awal dan akhir dari string masing-masing. Ingat bahwa saya menulis kamu mungkin ingin mencocokkan seluruh string, daripada mencari pencocokan substring? Beginilah caramu melakukannya. ^c[oau]t$ mencocokkan "cat", "cot", atau "cut", tetapi tidak, katakanlah "catch" atau "recut".

Batas Kata

\b merupakan batas antara kata-kata, seperti spasi atau tanda baca, dan juga awal atau akhir string. Perhatikan bahwa ini sedikit berbeda dalam hal mencocokan dengan posisi daripada karakter eksplisit. Ini mungkin bisa membantu dalam memikirkan batas kata sebagai pembatas tak terlihat yang memisahkan kata dari kata sebelumnya/berikutnya. Seperti yang kamu harapkan, \B mewakili "bukan batas kata". \bcat\b menemukan pencocokan di "cat", "a cat", "Hi,cat", tetapi tidak di "acat" atau "catch".

Negasi

Gagasan negasi bisa dibuat lebih spesifik dengan menggunakan metakarakter ^ di dalam set karakter. Ini adalah penggunaan yang sama sekali berbeda ^ dari "permulaan jangkar string". Ini berarti bahwa, untuk negasi, ^ harus digunakan dalam set karakter sejak awal. [^a] cocok dengan karakter selain huruf "a" dan [^ a-z] cocok dengan karakter kecuali huruf kecil.

Dapatkah kamu mewakili \W menggunakan rentang negasi dan karakter? Jawabannya adalah [^A-Za-z0-9_]. Apa yang kamu pikirkan [a^] akan cocok? Jawabannya adalah salah satu karakter "a" atau "^" karena tidak terjadi pada awal set karakter. Di sini "^" pencocokan itu sendiri secara harfiah.

Selain itu, kita bisa menghindarinya secara eksplisit seperti ini: [\^a]. Semoga, kamu mulai mengembangkan beberapa intuisi tentang bagaimana cara pelolosan bekerja.

Pembilang

Kita melihat bagaimana * (dan +) dapat digunakan untuk mencocokkan nol token atau lebih (dan satu atau lebih) kali. Gagasan untuk mencocokkan token beberapa kali dapat dibuat lebih spesifik menggunakan pengukur angka dalam kurung kurawal. Misalnya, {2, 4} berarti dua sampai empat pencocokan dari token sebelumnya. {2,} berarti dua atau lebih pencocokan dan {2} berarti dua pencocokan.

Kita akan melihat contoh terperinci yang menggunakan sebagian besar elemen ini pada tutorial berikutnya. Tetapi demi latihan, saya mendorongmu untuk membuat contohmu sendiri dan menguji sintaks yang baru saja kita lihat dengan tool RegExr.

Kesimpulan

Pada tutorial ini, kita terutama berfokus pada teori dan sintaks regular expression. Pada tutorial berikutnya, kita tambahkan Swift ke dalam campuran. Sebelum berpindah, pastikan kamu mengerti apa yang telah kita bahas dalam tutorial ini dengan bermain-main dengan RegExr.