Di MySQL, REGEXP_INSTR() fungsi mengembalikan indeks awal substring yang cocok dengan pola ekspresi reguler.
Indeks dimulai dari 1 . Jika tidak ada yang cocok, hasilnya adalah 0 .
Sintaks
Sintaksnya seperti ini:
REGEXP_INSTR(expr, pat[, pos[, kejadian[, return_option[, match_type]]]])
Dimana expr adalah string input dan pat adalah pola ekspresi reguler untuk substring.
pos opsional argumen memungkinkan Anda untuk menentukan posisi dalam string untuk memulai pencarian. Jika dihilangkan, dimulai dari posisi 1.
occurrence opsional argumen memungkinkan Anda untuk menentukan kemunculan kecocokan mana yang akan dicari. Jika dihilangkan, kemunculan pertama digunakan (kejadian 1).
return_option opsional argumen memungkinkan Anda untuk menentukan jenis posisi yang akan dikembalikan. Jika Anda menggunakan 0 , itu akan mengembalikan posisi karakter pertama dalam substring yang cocok. Jika Anda menggunakan 1 ia mengembalikan posisi karakter pertama mengikuti substring yang cocok. Jika dihilangkan, nilainya adalah 0 .
match_type opsional argumen memungkinkan Anda untuk memperbaiki ekspresi reguler. Misalnya, Anda dapat menggunakan argumen ini untuk menentukan pencocokan peka huruf besar-kecil atau tidak.
Contoh 1 – Penggunaan Dasar
Berikut ini contoh dasarnya:
SELECT REGEXP_INSTR('Cat', 'at') Hasil; Hasil:
+--------+| Hasil |+--------+| 2 |+--------+
Dalam hal ini ada kecocokan, dan substring dimulai pada posisi 2.
Contoh 2 – Tidak Cocok
Berikut ini contoh di mana tidak ada kecocokan:
SELECT REGEXP_INSTR('Kucing', '^at') Hasil; Hasil:
+--------+| Hasil |+--------+| 0 |+--------+
Tidak ada yang cocok, jadi hasilnya 0 . Tidak ada kecocokan karena saya menetapkan bahwa string harus dimulai dengan substring.
Mari kita ubah agar tidak mulai dengan substring itu:
SELECT REGEXP_INSTR('at', '^at') Hasil; Hasil:
+--------+| Hasil |+--------+| 1 |+--------+
Contoh 3 – pos Argumen
Berikut ini contoh menentukan posisi awal:
SELECT REGEXP_INSTR('Kucing Kucing', 'Kucing', 2) Hasil; Hasil:
+--------+| Hasil |+--------+| 5 |+--------+
Jadi kita mendapatkan indeks kejadian kedua.
Perhatikan bahwa indeks masih mulai menghitung dari posisi 1 di mana pun Anda menentukan posisi awal.
Contoh berikut menunjukkan hal ini dengan lebih jelas:
SELECT REGEXP_INSTR('Kucing Kucing', 'Kucing', 2) AS 'Pos 2', REGEXP_INSTR('Kucing Kucing', 'Kucing', 3) AS 'Pos 3', REGEXP_INSTR('Kucing Kucing', ' Cat', 5) SEBAGAI 'Pos 5'; Hasil:
+-------+-------+-------+| Pos 2 | Pos 3 | Pos 5 |+-------+-------+-------+| 5 | 5 | 5 |+-------+-------+-------+
Tentu saja, tergantung pada pola regex Anda, ini dapat mengembalikan indeks substring yang sama sekali berbeda. Contoh:
SELECT REGEXP_INSTR('Kota Kucing Sangat Imut!', 'C.t', 1) 'Pos 1', REGEXP_INSTR('Kota Kucing SANGAT Imut!', 'C.t', 2) 'Pos 2 ', REGEXP_INSTR('Kota Kucing Sangat Lucu!', 'C.t', 6) 'Pos 6'; Hasil:
+-------+-------+-------+| Pos 1 | Pos 2 | Pos 6 |+-------+-------+-------+| 1 | 5 | 16 |+-------+-------+-------+
Kita dapat memeriksa substring dengan REGEXP_SUBSTR() fungsi:
SELECT REGEXP_SUBSTR('Kota Kucing Sangat Imut!', 'C.t', 1) 'Pos 1', REGEXP_SUBSTR('Kota Kucing SANGAT Imut!', 'C.t', 2) 'Pos 2 ', REGEXP_SUBSTR('Kota Kucing Sangat Lucu!', 'C.t', 6) 'Pos 6'; Hasil:
+-------+-------+-------+| Pos 1 | Pos 2 | Pos 6 |+-------+-------+-------+| Kucing | Cit | Potong |+-------+-------+-------+
Contoh 4 – occurrence Argumen
Berikut ini contoh penggunaan occurrence argumen. Dalam semua kasus, kita mulai dari posisi 1:
SELECT REGEXP_INSTR('Kota Kucing Sangat Lucu!', 'C.t', 1, 1) 'Kejadian 1', REGEXP_INSTR('Kota Kucing Sangat Lucu!', 'C.t', 1, 2 ) 'Kejadian 2', REGEXP_INSTR('Kota Kucing SANGAT Imut!', 'C.t', 1, 3) 'Kejadian 3'; Hasil:
+-------------+--------------+--------------+| Kejadian 1 | Kejadian 2 | Kejadian 3 |+--------------+--------------+--------------+| 1 | 5 | 16 |+--------------+--------------+--------------+Namun, jika kita mulai dari posisi yang berbeda, hasilnya berbeda:
SELECT REGEXP_INSTR('Cat City Imut!', 'C.t', 2, 1) 'Occurrence 1', REGEXP_INSTR('Cat City SANGAT Imut!', 'C.t', 2, 2 ) 'Kejadian 2', REGEXP_INSTR('Kota Kucing SANGAT Imut!', 'C.t', 2, 3) 'Kejadian 3';Hasil:
+-------------+--------------+--------------+| Kejadian 1 | Kejadian 2 | Kejadian 3 |+--------------+--------------+--------------+| 5 | 16 | 0 |+--------------+--------------+--------------+Ini terjadi karena posisi awal kami datang setelah kejadian pertama dimulai. Oleh karena itu, kejadian 2 menjadi kejadian 1, dan kejadian 3 menjadi kejadian 2. Dan karena tidak ada kejadian lagi, hasil kejadian 3 negatif (yaitu tidak ada kejadian 3).
Contoh 5 –
return_optionArgumenBerikut ini contoh penggunaan
return_optionargumen:SELECT REGEXP_INSTR('Kota Kucing Sangat Imut!', 'C.t', 1, 1, 0) 'Opsi 0', REGEXP_INSTR('Kota Kucing SANGAT Imut!', 'C.t', 1 , 1, 1) 'Opsi 1';Hasil:
+----------+----------+| Opsi 0 | Opsi 1 |+----------+----------+| 1 | 4 |+----------+----------+Opsi 0 mengembalikan karakter pertama substring yang cocok. Opsi 1 mengembalikan posisi setelah substring yang cocok.
Berikut tampilannya jika kita terapkan pada contoh sebelumnya:
SELECT REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 0) 'Occurrence 1', REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1 , 2, 0) 'Occurrence 2', REGEXP_INSTR('Cat City is so Cute!', 'C.t', 1, 3, 0) 'Occurrence 3'UNION ALLSELECT REGEXP_INSTR('Cat City is SO Cute!', 'C.t', 1, 1, 1), REGEXP_INSTR('Kota Kucing Imut!', 'C.t', 1, 2, 1), REGEXP_INSTR('Kota Kucing Imut!', 'C .t', 1, 3, 1);Hasil:
+-------------+--------------+--------------+| Kejadian 1 | Kejadian 2 | Kejadian 3 |+--------------+--------------+--------------+| 1 | 5 | 16 || 4 | 8 | 19 |+--------------+--------------+--------------+Dalam hal ini kami melakukan satu set menggunakan opsi 0, dan yang lain menggunakan opsi 1, lalu menggabungkannya menggunakan
UNION ALL.Contoh 6 –
match_typeArgumenAnda dapat memberikan argumen tambahan untuk menentukan jenis pencocokan. Ini memungkinkan Anda untuk menentukan hal-hal seperti apakah kecocokan peka huruf besar-kecil atau tidak, apakah akan menyertakan terminator baris atau tidak, dll.
Berikut adalah contoh menentukan kecocokan peka huruf besar-kecil dan kecocokan peka huruf besar/kecil:
SELECT REGEXP_INSTR('Kota Kucing Sangat Lucu!', 'c.t', 1, 1, 0, 'c') 'Sensitif Huruf Besar', REGEXP_INSTR('Kota Kucing Sangat Lucu!', 'c .t', 1, 1, 0, 'i') 'Peka Huruf Besar-kecil';Hasil:
+----------------+------------------+| Peka Huruf Besar-kecil | Tidak peka huruf besar/kecil |+----------------+------------------+| 0 | 1 |+----------------+------------------+
match_typeargumen dapat berisi karakter berikut:
c- Pencocokan peka huruf besar/kecil.
i- Pencocokan peka huruf besar/kecil.
m- Mode banyak baris. Kenali terminator garis di dalam string. Perilaku default adalah mencocokkan terminator baris hanya di awal dan akhir ekspresi string.
n.karakter cocok dengan terminator garis. Standarnya adalah untuk.cocok untuk berhenti di akhir baris.u- Akhir baris khusus Unix. Hanya karakter baris baru yang dikenali sebagai baris yang diakhiri dengan
.,^, dan$operator pertandingan.
